diff --git a/lib/hooks/child-threads.js b/lib/hooks/child-threads.js
index 81dd320ff..c47da1969 100644
--- a/lib/hooks/child-threads.js
+++ b/lib/hooks/child-threads.js
@@ -1,135 +1,136 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   fetchSingleMostRecentMessagesFromThreadsActionTypes,
   useFetchSingleMostRecentMessagesFromThreads,
 } from '../actions/message-actions.js';
 import {
   type ChatThreadItem,
   useFilteredChatListData,
 } from '../selectors/chat-selectors.js';
 import { useGlobalThreadSearchIndex } from '../selectors/nav-selectors.js';
 import { childThreadInfos } from '../selectors/thread-selectors.js';
 import { useThreadsInChatList } from '../shared/thread-utils.js';
 import threadWatcher from '../shared/thread-watcher.js';
 import type {
   ThreadInfo,
   RawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 type ThreadFilter = {
   +predicate?: (thread: ThreadInfo) => boolean,
   +searchText?: string,
 };
 
 function useFilteredChildThreads(
   threadID: string,
   filter?: ThreadFilter,
 ): $ReadOnlyArray<ChatThreadItem> {
   const defaultPredicate = React.useCallback(() => true, []);
   const { predicate = defaultPredicate, searchText = '' } = filter ?? {};
   const childThreads = useSelector(state => childThreadInfos(state)[threadID]);
   const subchannelIDs = React.useMemo(() => {
     if (!childThreads) {
       return new Set<string>();
     }
     return new Set<string>(
       childThreads.filter(predicate).map(threadInfo => threadInfo.id),
     );
   }, [childThreads, predicate]);
 
   const filterSubchannels = React.useCallback(
     (thread: ?(RawThreadInfo | ThreadInfo)) => {
       const candidateThreadID = thread?.id;
       if (!candidateThreadID) {
         return false;
       }
       return subchannelIDs.has(candidateThreadID);
     },
     [subchannelIDs],
   );
   const allSubchannelsList = useFilteredChatListData(filterSubchannels);
 
   const searchIndex = useGlobalThreadSearchIndex();
 
   const searchResultIDs = React.useMemo(
     () => searchIndex.getSearchResults(searchText),
     [searchIndex, searchText],
   );
 
   const searchTextExists = !!searchText.length;
 
   const subchannelsThreadInfos = React.useMemo(
     () => allSubchannelsList.map(item => item.threadInfo),
     [allSubchannelsList],
   );
   const subchannelsInChatList = useThreadsInChatList(subchannelsThreadInfos);
   const subchannelIDsInChatList = React.useMemo(
     () => new Set(subchannelsInChatList.map(thread => thread.id)),
     [subchannelsInChatList],
   );
 
   const subchannelIDsNotInChatList = React.useMemo(
     () =>
       new Set(
         allSubchannelsList
           .filter(item => !subchannelIDsInChatList.has(item.threadInfo.id))
           .map(item => item.threadInfo.id),
       ),
     [allSubchannelsList, subchannelIDsInChatList],
   );
 
   React.useEffect(() => {
     if (!subchannelIDsNotInChatList.size) {
       return undefined;
     }
     subchannelIDsNotInChatList.forEach(tID => threadWatcher.watchID(tID));
 
     return () =>
       subchannelIDsNotInChatList.forEach(tID => threadWatcher.removeID(tID));
   }, [subchannelIDsNotInChatList]);
 
   const filteredSubchannelsChatList = React.useMemo(() => {
     if (!searchTextExists) {
       return allSubchannelsList;
     }
     return allSubchannelsList.filter(item =>
       searchResultIDs.includes(item.threadInfo.id),
     );
   }, [allSubchannelsList, searchResultIDs, searchTextExists]);
 
+  const messageStore = useSelector(state => state.messageStore);
   const threadIDsWithNoMessages = React.useMemo(
     () =>
       new Set(
         filteredSubchannelsChatList
-          .filter(item => !item.mostRecentMessageInfo)
-          .map(item => item.threadInfo.id),
+          .map(item => item.threadInfo.id)
+          .filter(id => messageStore.threads[id]?.messageIDs.length === 0),
       ),
-    [filteredSubchannelsChatList],
+    [filteredSubchannelsChatList, messageStore],
   );
   const dispatchActionPromise = useDispatchActionPromise();
   const fetchSingleMostRecentMessages =
     useFetchSingleMostRecentMessagesFromThreads();
 
   React.useEffect(() => {
     if (!threadIDsWithNoMessages.size) {
       return;
     }
     void dispatchActionPromise(
       fetchSingleMostRecentMessagesFromThreadsActionTypes,
       fetchSingleMostRecentMessages(Array.from(threadIDsWithNoMessages)),
     );
   }, [
     threadIDsWithNoMessages,
     fetchSingleMostRecentMessages,
     dispatchActionPromise,
   ]);
 
   return filteredSubchannelsChatList;
 }
 
 export { useFilteredChildThreads };
diff --git a/lib/hooks/message-hooks.js b/lib/hooks/message-hooks.js
index a994d68e5..e2dd34534 100644
--- a/lib/hooks/message-hooks.js
+++ b/lib/hooks/message-hooks.js
@@ -1,12 +1,55 @@
 // @flow
 
+import * as React from 'react';
+
+import { messageInfoSelector } from '../selectors/chat-selectors.js';
 import { getOldestNonLocalMessageID } from '../shared/message-utils.js';
+import type { MessageInfo } from '../types/message-types.js';
+import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function useOldestMessageServerID(threadID: string): ?string {
   return useSelector(state =>
     getOldestNonLocalMessageID(threadID, state.messageStore),
   );
 }
 
-export { useOldestMessageServerID };
+function useGetMessageInfoForPreview(): (
+  threadInfo: ThreadInfo,
+) => Promise<?MessageInfo> {
+  const messageInfos = useSelector(messageInfoSelector);
+  const messageStore = useSelector(state => state.messageStore);
+  return React.useCallback(
+    async threadInfo => {
+      const thread = messageStore.threads[threadInfo.id];
+      if (!thread) {
+        return null;
+      }
+      for (const messageID of thread.messageIDs) {
+        const messageInfo = messageInfos[messageID];
+        if (messageInfo) {
+          return messageInfo;
+        }
+      }
+      return null;
+    },
+    [messageInfos, messageStore],
+  );
+}
+
+function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
+  const [messageInfo, setMessageInfo] = React.useState<?MessageInfo>();
+
+  const getMessageInfoForPreview = useGetMessageInfoForPreview();
+  React.useEffect(() => {
+    void (async () => {
+      const newMessageInfoForPreview =
+        await getMessageInfoForPreview(threadInfo);
+      setMessageInfo(newMessageInfoForPreview);
+    })();
+  }, [threadInfo, getMessageInfoForPreview]);
+
+  return messageInfo;
+}
+
+export { useOldestMessageServerID, useMessageInfoForPreview };
diff --git a/lib/selectors/chat-selectors.js b/lib/selectors/chat-selectors.js
index 5c3f5734b..05a5f54b9 100644
--- a/lib/selectors/chat-selectors.js
+++ b/lib/selectors/chat-selectors.js
@@ -1,698 +1,696 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter.js';
 import _flow from 'lodash/fp/flow.js';
 import _map from 'lodash/fp/map.js';
 import _orderBy from 'lodash/fp/orderBy.js';
 import * as React from 'react';
 import { createSelector } from 'reselect';
 import { createObjectSelector } from 'reselect-map';
 
 import {
   threadInfoFromSourceMessageIDSelector,
   threadInfoSelector,
 } from './thread-selectors.js';
 import { sidebarInfoSelector } from '../selectors/sidebar-selectors.js';
 import {
   createMessageInfo,
   getMostRecentNonLocalMessageID,
   messageKey,
   robotextForMessageInfo,
   sortMessageInfoList,
 } from '../shared/message-utils.js';
 import { messageSpecs } from '../shared/messages/message-specs.js';
 import { threadInChatList, threadIsPending } from '../shared/thread-utils.js';
 import { messageTypes } from '../types/message-types-enum.js';
 import {
   type ComposableMessageInfo,
   isComposableMessageType,
   type LocalMessageInfo,
   type MessageInfo,
   type MessageStore,
   type RobotextMessageInfo,
 } from '../types/message-types.js';
 import type {
   ThreadInfo,
   RawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { BaseAppState } from '../types/redux-types.js';
 import { threadTypeIsSidebar } from '../types/thread-types-enum.js';
 import {
   maxReadSidebars,
   maxUnreadSidebars,
   type SidebarInfo,
 } from '../types/thread-types.js';
 import type {
   AccountUserInfo,
   RelativeUserInfo,
   UserInfo,
 } from '../types/user-types.js';
 import { threeDays } from '../utils/date-utils.js';
 import type { EntityText } from '../utils/entity-text.js';
 import memoize2 from '../utils/memoize.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type SidebarItem =
   | {
       ...SidebarInfo,
       +type: 'sidebar',
     }
   | {
       +type: 'seeMore',
       +unread: boolean,
     }
   | { +type: 'spacer' };
 
 export type ChatThreadItem = {
   +type: 'chatThreadItem',
   +threadInfo: ThreadInfo,
-  +mostRecentMessageInfo: ?MessageInfo,
   +mostRecentNonLocalMessage: ?string,
   +lastUpdatedTime: number,
   +lastUpdatedTimeIncludingSidebars: number,
   +sidebars: $ReadOnlyArray<SidebarItem>,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
 
 const messageInfoSelector: (state: BaseAppState<>) => {
   +[id: string]: ?MessageInfo,
 } = createObjectSelector(
   (state: BaseAppState<>) => state.messageStore.messages,
   (state: BaseAppState<>) => state.currentUserInfo && state.currentUserInfo.id,
   (state: BaseAppState<>) => state.userStore.userInfos,
   threadInfoSelector,
   createMessageInfo,
 );
 
 function isEmptyMediaMessage(messageInfo: MessageInfo): boolean {
   return (
     (messageInfo.type === messageTypes.MULTIMEDIA ||
       messageInfo.type === messageTypes.IMAGES) &&
     messageInfo.media.length === 0
   );
 }
 
 function getMostRecentMessageInfo(
   threadInfo: ThreadInfo,
   messageStore: MessageStore,
   messages: { +[id: string]: ?MessageInfo },
 ): ?MessageInfo {
   const thread = messageStore.threads[threadInfo.id];
   if (!thread) {
     return null;
   }
   for (const messageID of thread.messageIDs) {
     const messageInfo = messages[messageID];
     if (!messageInfo || isEmptyMediaMessage(messageInfo)) {
       continue;
     }
     return messageInfo;
   }
   return null;
 }
 
 function getLastUpdatedTime(
   threadInfo: ThreadInfo,
   mostRecentMessageInfo: ?MessageInfo,
 ): number {
   return mostRecentMessageInfo
     ? mostRecentMessageInfo.time
     : threadInfo.creationTime;
 }
 
 function useCreateChatThreadItem(): ThreadInfo => ChatThreadItem {
   const messageInfos = useSelector(messageInfoSelector);
   const sidebarInfos = useSelector(sidebarInfoSelector);
   const messageStore = useSelector(state => state.messageStore);
   return React.useCallback(
     threadInfo => {
       const mostRecentMessageInfo = getMostRecentMessageInfo(
         threadInfo,
         messageStore,
         messageInfos,
       );
       const mostRecentNonLocalMessage = getMostRecentNonLocalMessageID(
         threadInfo.id,
         messageStore,
       );
       const lastUpdatedTime = getLastUpdatedTime(
         threadInfo,
         mostRecentMessageInfo,
       );
 
       const sidebars = sidebarInfos[threadInfo.id] ?? [];
       const allSidebarItems = sidebars.map(sidebarInfo => ({
         type: 'sidebar',
         ...sidebarInfo,
       }));
       const lastUpdatedTimeIncludingSidebars =
         allSidebarItems.length > 0
           ? Math.max(lastUpdatedTime, allSidebarItems[0].lastUpdatedTime)
           : lastUpdatedTime;
 
       const numUnreadSidebars = allSidebarItems.filter(
         sidebar => sidebar.threadInfo.currentUser.unread,
       ).length;
       let numReadSidebarsToShow = maxReadSidebars - numUnreadSidebars;
       const threeDaysAgo = Date.now() - threeDays;
 
       const sidebarItems: SidebarItem[] = [];
       for (const sidebar of allSidebarItems) {
         if (sidebarItems.length >= maxUnreadSidebars) {
           break;
         } else if (sidebar.threadInfo.currentUser.unread) {
           sidebarItems.push(sidebar);
         } else if (
           sidebar.lastUpdatedTime > threeDaysAgo &&
           numReadSidebarsToShow > 0
         ) {
           sidebarItems.push(sidebar);
           numReadSidebarsToShow--;
         }
       }
 
       const numReadButRecentSidebars = allSidebarItems.filter(
         sidebar =>
           !sidebar.threadInfo.currentUser.unread &&
           sidebar.lastUpdatedTime > threeDaysAgo,
       ).length;
       if (
         sidebarItems.length < numUnreadSidebars + numReadButRecentSidebars ||
         (sidebarItems.length < allSidebarItems.length &&
           sidebarItems.length > 0)
       ) {
         sidebarItems.push({
           type: 'seeMore',
           unread: numUnreadSidebars > maxUnreadSidebars,
         });
       }
       if (sidebarItems.length !== 0) {
         sidebarItems.push({
           type: 'spacer',
         });
       }
 
       return {
         type: 'chatThreadItem',
         threadInfo,
-        mostRecentMessageInfo,
         mostRecentNonLocalMessage,
         lastUpdatedTime,
         lastUpdatedTimeIncludingSidebars,
         sidebars: sidebarItems,
       };
     },
     [messageInfos, messageStore, sidebarInfos],
   );
 }
 
 function useFlattenedChatListData(): $ReadOnlyArray<ChatThreadItem> {
   return useFilteredChatListData(threadInChatList);
 }
 
 function useFilteredChatListData(
   filterFunction: (threadInfo: ?(ThreadInfo | RawThreadInfo)) => boolean,
 ): $ReadOnlyArray<ChatThreadItem> {
   const threadInfos = useSelector(threadInfoSelector);
   const getChatThreadItem = useCreateChatThreadItem();
   return React.useMemo(
     () =>
       _flow(
         _filter(filterFunction),
         _map(getChatThreadItem),
         _orderBy('lastUpdatedTimeIncludingSidebars')('desc'),
       )(threadInfos),
     [getChatThreadItem, filterFunction, threadInfos],
   );
 }
 
 export type RobotextChatMessageInfoItem = {
   +itemType: 'message',
   +messageInfoType: 'robotext',
   +messageInfos: $ReadOnlyArray<RobotextMessageInfo>,
   +startsConversation: boolean,
   +startsCluster: boolean,
   endsCluster: boolean,
   +robotext: EntityText,
   +threadCreatedFromMessage: ?ThreadInfo,
   +reactions: ReactionInfo,
 };
 export type ComposableChatMessageInfoItem = {
   +itemType: 'message',
   +messageInfoType: 'composable',
   +messageInfo: ComposableMessageInfo,
   +localMessageInfo: ?LocalMessageInfo,
   +startsConversation: boolean,
   +startsCluster: boolean,
   endsCluster: boolean,
   +threadCreatedFromMessage: ?ThreadInfo,
   +reactions: ReactionInfo,
   +hasBeenEdited: boolean,
   +isPinned: boolean,
 };
 export type ChatMessageInfoItem =
   | RobotextChatMessageInfoItem
   | ComposableChatMessageInfoItem;
 export type ChatMessageItem = { itemType: 'loader' } | ChatMessageInfoItem;
 
 export type ReactionInfo = { +[reaction: string]: MessageReactionInfo };
 type MessageReactionInfo = {
   +viewerReacted: boolean,
   +users: $ReadOnlyArray<RelativeUserInfo>,
 };
 type TargetMessageReactions = Map<string, Map<string, RelativeUserInfo>>;
 
 const msInFiveMinutes = 5 * 60 * 1000;
 function createChatMessageItems(
   threadID: string,
   messageStore: MessageStore,
   messageInfos: { +[id: string]: ?MessageInfo },
   threadInfos: { +[id: string]: ThreadInfo },
   threadInfoFromSourceMessageID: {
     +[id: string]: ThreadInfo,
   },
   additionalMessages: $ReadOnlyArray<MessageInfo>,
   viewerID: string,
 ): ChatMessageItem[] {
   const thread = messageStore.threads[threadID];
 
   const threadMessageInfos = (thread?.messageIDs ?? [])
     .map((messageID: string) => messageInfos[messageID])
     .filter(Boolean);
   const messages =
     additionalMessages.length > 0
       ? sortMessageInfoList([...threadMessageInfos, ...additionalMessages])
       : threadMessageInfos;
 
   const targetMessageReactionsMap = new Map<string, TargetMessageReactions>();
 
   // We need to iterate backwards to put the order of messages in chronological
   // order, starting with the oldest. This avoids the scenario where the most
   // recent message with the remove_reaction action may try to remove a user
   // that hasn't been added to the messageReactionUsersInfoMap, causing it
   // to be skipped.
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.REACTION) {
       continue;
     }
 
     if (!targetMessageReactionsMap.has(messageInfo.targetMessageID)) {
       const reactsMap: TargetMessageReactions = new Map();
       targetMessageReactionsMap.set(messageInfo.targetMessageID, reactsMap);
     }
 
     const messageReactsMap = targetMessageReactionsMap.get(
       messageInfo.targetMessageID,
     );
     invariant(messageReactsMap, 'messageReactsInfo should be set');
 
     if (!messageReactsMap.has(messageInfo.reaction)) {
       const usersInfoMap = new Map<string, RelativeUserInfo>();
       messageReactsMap.set(messageInfo.reaction, usersInfoMap);
     }
 
     const messageReactionUsersInfoMap = messageReactsMap.get(
       messageInfo.reaction,
     );
     invariant(
       messageReactionUsersInfoMap,
       'messageReactionUsersInfoMap should be set',
     );
 
     if (messageInfo.action === 'add_reaction') {
       messageReactionUsersInfoMap.set(
         messageInfo.creator.id,
         messageInfo.creator,
       );
     } else {
       messageReactionUsersInfoMap.delete(messageInfo.creator.id);
     }
   }
 
   const targetMessageEditMap = new Map<string, string>();
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.EDIT_MESSAGE) {
       continue;
     }
     targetMessageEditMap.set(messageInfo.targetMessageID, messageInfo.text);
   }
 
   const targetMessagePinStatusMap = new Map<string, boolean>();
   // Once again, we iterate backwards to put the order of messages in
   // chronological order (i.e. oldest to newest) to handle pinned messages.
   // This is important because we want to make sure that the most recent pin
   // action is the one that is used to determine whether a message
   // is pinned or not.
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
     if (messageInfo.type !== messageTypes.TOGGLE_PIN) {
       continue;
     }
 
     targetMessagePinStatusMap.set(
       messageInfo.targetMessageID,
       messageInfo.action === 'pin',
     );
   }
 
   const chatMessageItems: ChatMessageItem[] = [];
   let lastMessageInfo = null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const messageInfo = messages[i];
 
     if (
       messageInfo.type === messageTypes.REACTION ||
       messageInfo.type === messageTypes.EDIT_MESSAGE
     ) {
       continue;
     }
 
     let originalMessageInfo =
       messageInfo.type === messageTypes.SIDEBAR_SOURCE
         ? messageInfo.sourceMessage
         : messageInfo;
 
     if (isEmptyMediaMessage(originalMessageInfo)) {
       continue;
     }
 
     let hasBeenEdited = false;
     if (
       originalMessageInfo.type === messageTypes.TEXT &&
       originalMessageInfo.id
     ) {
       const newText = targetMessageEditMap.get(originalMessageInfo.id);
       if (newText !== undefined) {
         hasBeenEdited = true;
         originalMessageInfo = {
           ...originalMessageInfo,
           text: newText,
         };
       }
     }
 
     let startsConversation = true;
     let startsCluster = true;
     if (
       lastMessageInfo &&
       lastMessageInfo.time + msInFiveMinutes > originalMessageInfo.time
     ) {
       startsConversation = false;
       if (
         isComposableMessageType(lastMessageInfo.type) &&
         isComposableMessageType(originalMessageInfo.type) &&
         lastMessageInfo.creator.id === originalMessageInfo.creator.id
       ) {
         startsCluster = false;
       }
     }
     if (startsCluster && chatMessageItems.length > 0) {
       const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
       invariant(lastMessageItem.itemType === 'message', 'should be message');
       lastMessageItem.endsCluster = true;
     }
     const threadCreatedFromMessage =
       !threadTypeIsSidebar(threadInfos[threadID]?.type) && messageInfo.id
         ? threadInfoFromSourceMessageID[messageInfo.id]
         : undefined;
 
     const isPinned = !!(
       originalMessageInfo.id &&
       targetMessagePinStatusMap.get(originalMessageInfo.id)
     );
 
     const renderedReactions: ReactionInfo = (() => {
       const result: { [string]: MessageReactionInfo } = {};
 
       let messageReactsMap;
       if (originalMessageInfo.id) {
         messageReactsMap = targetMessageReactionsMap.get(
           originalMessageInfo.id,
         );
       }
 
       if (!messageReactsMap) {
         return result;
       }
 
       for (const reaction of messageReactsMap.keys()) {
         const reactionUsersInfoMap = messageReactsMap.get(reaction);
         invariant(reactionUsersInfoMap, 'reactionUsersInfoMap should be set');
 
         if (reactionUsersInfoMap.size === 0) {
           continue;
         }
 
         const reactionUserInfos = [...reactionUsersInfoMap.values()];
 
         const messageReactionInfo = {
           users: reactionUserInfos,
           viewerReacted: reactionUsersInfoMap.has(viewerID),
         };
 
         result[reaction] = messageReactionInfo;
       }
 
       return result;
     })();
 
     const threadInfo = threadInfos[threadID];
     const parentThreadInfo = threadInfo?.parentThreadID
       ? threadInfos[threadInfo.parentThreadID]
       : null;
 
     const lastChatMessageItem =
       chatMessageItems.length > 0
         ? chatMessageItems[chatMessageItems.length - 1]
         : undefined;
     const messageSpec = messageSpecs[originalMessageInfo.type];
     if (
       !threadCreatedFromMessage &&
       Object.keys(renderedReactions).length === 0 &&
       !hasBeenEdited &&
       !isPinned &&
       lastChatMessageItem &&
       lastChatMessageItem.itemType === 'message' &&
       lastChatMessageItem.messageInfoType === 'robotext' &&
       !lastChatMessageItem.threadCreatedFromMessage &&
       Object.keys(lastChatMessageItem.reactions).length === 0 &&
       !isComposableMessageType(originalMessageInfo.type) &&
       messageSpec?.mergeIntoPrecedingRobotextMessageItem
     ) {
       const { mergeIntoPrecedingRobotextMessageItem } = messageSpec;
       const mergeResult = mergeIntoPrecedingRobotextMessageItem(
         originalMessageInfo,
         lastChatMessageItem,
         { threadInfo, parentThreadInfo },
       );
       if (mergeResult.shouldMerge) {
         chatMessageItems[chatMessageItems.length - 1] = mergeResult.item;
         continue;
       }
     }
 
     if (isComposableMessageType(originalMessageInfo.type)) {
       // We use these invariants instead of just checking the messageInfo.type
       // directly in the conditional above so that isComposableMessageType can
       // be the source of truth
       invariant(
         originalMessageInfo.type === messageTypes.TEXT ||
           originalMessageInfo.type === messageTypes.IMAGES ||
           originalMessageInfo.type === messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const localMessageInfo =
         messageStore.local[messageKey(originalMessageInfo)];
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'composable',
         messageInfo: originalMessageInfo,
         localMessageInfo,
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         reactions: renderedReactions,
         hasBeenEdited,
         isPinned,
       });
     } else {
       invariant(
         originalMessageInfo.type !== messageTypes.TEXT &&
           originalMessageInfo.type !== messageTypes.IMAGES &&
           originalMessageInfo.type !== messageTypes.MULTIMEDIA,
         "Flow doesn't understand isComposableMessageType above",
       );
       const robotext = robotextForMessageInfo(
         originalMessageInfo,
         threadInfo,
         parentThreadInfo,
       );
       chatMessageItems.push({
         itemType: 'message',
         messageInfoType: 'robotext',
         messageInfos: [originalMessageInfo],
         startsConversation,
         startsCluster,
         endsCluster: false,
         threadCreatedFromMessage,
         robotext,
         reactions: renderedReactions,
       });
     }
     lastMessageInfo = originalMessageInfo;
   }
   if (chatMessageItems.length > 0) {
     const lastMessageItem = chatMessageItems[chatMessageItems.length - 1];
     invariant(lastMessageItem.itemType === 'message', 'should be message');
     lastMessageItem.endsCluster = true;
   }
   chatMessageItems.reverse();
   const hideSpinner = thread ? thread.startReached : threadIsPending(threadID);
   if (hideSpinner) {
     return chatMessageItems;
   }
   return [...chatMessageItems, ({ itemType: 'loader' }: ChatMessageItem)];
 }
 
 const baseMessageListData = (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ): ((state: BaseAppState<>) => ?(ChatMessageItem[])) =>
   createSelector(
     (state: BaseAppState<>) => state.messageStore,
     messageInfoSelector,
     threadInfoSelector,
     threadInfoFromSourceMessageIDSelector,
     (state: BaseAppState<>) =>
       state.currentUserInfo && state.currentUserInfo.id,
     (
       messageStore: MessageStore,
       messageInfos: { +[id: string]: ?MessageInfo },
       threadInfos: {
         +[id: string]: ThreadInfo,
       },
       threadInfoFromSourceMessageID: {
         +[id: string]: ThreadInfo,
       },
       viewerID: ?string,
     ): ?(ChatMessageItem[]) => {
       if (!threadID || !viewerID) {
         return null;
       }
       return createChatMessageItems(
         threadID,
         messageStore,
         messageInfos,
         threadInfos,
         threadInfoFromSourceMessageID,
         additionalMessages,
         viewerID,
       );
     },
   );
 export type MessageListData = ?(ChatMessageItem[]);
 const messageListData: (
   threadID: ?string,
   additionalMessages: $ReadOnlyArray<MessageInfo>,
 ) => (state: BaseAppState<>) => MessageListData = memoize2(baseMessageListData);
 
 export type UseMessageListDataArgs = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +threadInfo: ?ThreadInfo,
 };
 
 function useMessageListData({
   searching,
   userInfoInputArray,
   threadInfo,
 }: UseMessageListDataArgs): MessageListData {
   const messageInfos = useSelector(messageInfoSelector);
 
   const containingThread = useSelector(state => {
     if (
       !threadInfo ||
       !threadTypeIsSidebar(threadInfo.type) ||
       !threadInfo.containingThreadID
     ) {
       return null;
     }
     return state.messageStore.threads[threadInfo.containingThreadID];
   });
 
   const pendingSidebarEditMessageInfo = React.useMemo(() => {
     const sourceMessageID = threadInfo?.sourceMessageID;
     const threadMessageInfos = (containingThread?.messageIDs ?? [])
       .map((messageID: string) => messageInfos[messageID])
       .filter(Boolean)
       .filter(
         message =>
           message.type === messageTypes.EDIT_MESSAGE &&
           message.targetMessageID === sourceMessageID,
       );
     if (threadMessageInfos.length === 0) {
       return null;
     }
     return threadMessageInfos[0];
   }, [threadInfo, containingThread, messageInfos]);
 
   const pendingSidebarSourceMessageInfo = useSelector(state => {
     const sourceMessageID = threadInfo?.sourceMessageID;
     if (
       !threadInfo ||
       !threadTypeIsSidebar(threadInfo.type) ||
       !sourceMessageID
     ) {
       return null;
     }
     const thread = state.messageStore.threads[threadInfo.id];
     const shouldSourceBeAdded =
       !thread ||
       (thread.startReached &&
         thread.messageIDs.every(
           id => messageInfos[id]?.type !== messageTypes.SIDEBAR_SOURCE,
         ));
     return shouldSourceBeAdded ? messageInfos[sourceMessageID] : null;
   });
 
   invariant(
     !pendingSidebarSourceMessageInfo ||
       pendingSidebarSourceMessageInfo.type !== messageTypes.SIDEBAR_SOURCE,
     'sidebars can not be created from sidebar_source message',
   );
 
   const additionalMessages = React.useMemo(() => {
     if (!pendingSidebarSourceMessageInfo) {
       return ([]: MessageInfo[]);
     }
     const result: MessageInfo[] = [pendingSidebarSourceMessageInfo];
     if (pendingSidebarEditMessageInfo) {
       result.push(pendingSidebarEditMessageInfo);
     }
     return result;
   }, [pendingSidebarSourceMessageInfo, pendingSidebarEditMessageInfo]);
   const boundMessageListData = useSelector(
     messageListData(threadInfo?.id, additionalMessages),
   );
 
   return React.useMemo(() => {
     if (searching && userInfoInputArray.length === 0) {
       return [];
     }
     return boundMessageListData;
   }, [searching, userInfoInputArray.length, boundMessageListData]);
 }
 
 export {
   messageInfoSelector,
   useCreateChatThreadItem,
   createChatMessageItems,
   messageListData,
   useFlattenedChatListData,
   useFilteredChatListData,
   useMessageListData,
 };
diff --git a/lib/shared/thread-utils.js b/lib/shared/thread-utils.js
index 2fc25e80e..e795ab978 100644
--- a/lib/shared/thread-utils.js
+++ b/lib/shared/thread-utils.js
@@ -1,1974 +1,1973 @@
 // @flow
 
 import invariant from 'invariant';
 import _find from 'lodash/fp/find.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _mapValues from 'lodash/fp/mapValues.js';
 import _omit from 'lodash/fp/omit.js';
 import _omitBy from 'lodash/fp/omitBy.js';
 import * as React from 'react';
 
 import { getUserAvatarForThread } from './avatar-utils.js';
 import { generatePendingThreadColor } from './color-utils.js';
 import { extractUserMentionsFromText } from './mention-utils.js';
 import { relationshipBlockedInEitherDirection } from './relationship-utils.js';
 import ashoat from '../facts/ashoat.js';
 import genesis from '../facts/genesis.js';
 import { useLoggedInUserInfo } from '../hooks/account-hooks.js';
 import { type UserSearchResult } from '../hooks/thread-search-hooks.js';
 import { useUsersSupportThickThreads } from '../hooks/user-identities-hooks.js';
 import { extractKeyserverIDFromIDOptional } from '../keyserver-conn/keyserver-call-utils.js';
 import {
   hasPermission,
   permissionsToBitmaskHex,
   threadPermissionsFromBitmaskHex,
 } from '../permissions/minimally-encoded-thread-permissions.js';
 import { specialRoles } from '../permissions/special-roles.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import {
   permissionLookup,
   getAllThreadPermissions,
   makePermissionsBlob,
 } from '../permissions/thread-permissions.js';
 import type {
   ChatThreadItem,
   SidebarItem,
 } from '../selectors/chat-selectors.js';
 import {
   threadInfoSelector,
   pendingToRealizedThreadIDsSelector,
   threadInfosSelectorForThreadType,
   onScreenThreadInfos,
 } from '../selectors/thread-selectors.js';
 import {
   getRelativeMemberInfos,
   usersWithPersonalThreadSelector,
 } from '../selectors/user-selectors.js';
 import type { AuxUserInfos } from '../types/aux-user-types.js';
 import type { RawDeviceList } from '../types/identity-service-types.js';
 import type {
   RelativeMemberInfo,
   RawThreadInfo,
   MemberInfoWithPermissions,
   RoleInfo,
   ThreadInfo,
   MinimallyEncodedThickMemberInfo,
   ThinRawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import {
   decodeMinimallyEncodedRoleInfo,
   minimallyEncodeMemberInfo,
   minimallyEncodeRawThreadInfoWithMemberPermissions,
   minimallyEncodeRoleInfo,
   minimallyEncodeThreadCurrentUserInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
 import { userRelationshipStatus } from '../types/relationship-types.js';
 import { defaultThreadSubscription } from '../types/subscription-types.js';
 import {
   threadPermissionPropagationPrefixes,
   threadPermissions,
   type ThreadPermission,
   type ThreadPermissionsInfo,
   type ThreadRolePermissionsBlob,
   type UserSurfacedPermission,
   threadPermissionFilterPrefixes,
   threadPermissionsDisabledByBlock,
   type ThreadPermissionNotAffectedByBlock,
 } from '../types/thread-permission-types.js';
 import {
   type ThreadType,
   threadTypes,
   threadTypeIsCommunityRoot,
   assertThreadType,
   threadTypeIsThick,
   assertThinThreadType,
   assertThickThreadType,
   threadTypeIsSidebar,
   threadTypeIsPrivate,
   threadTypeIsPersonal,
   type ThinThreadType,
 } from '../types/thread-types-enum.js';
 import type {
   LegacyRawThreadInfo,
   ClientLegacyRoleInfo,
   ServerThreadInfo,
   ThickMemberInfo,
   UserProfileThreadInfo,
   MixedRawThreadInfos,
   LegacyThinRawThreadInfo,
   ThreadTimestamps,
 } from '../types/thread-types.js';
 import { updateTypes } from '../types/update-types-enum.js';
 import { type ClientUpdateInfo } from '../types/update-types.js';
 import type {
   UserInfos,
   AccountUserInfo,
   LoggedInUserInfo,
   UserInfo,
 } from '../types/user-types.js';
 import {
   ET,
   type ThreadEntity,
   type UserEntity,
 } from '../utils/entity-text.js';
 import {
   stripMemberPermissionsFromRawThreadInfo,
   type ThinRawThreadInfoWithPermissions,
 } from '../utils/member-info-utils.js';
 import { entries, values } from '../utils/objects.js';
 import { useSelector } from '../utils/redux-utils.js';
 import { userSurfacedPermissionsFromRolePermissions } from '../utils/role-utils.js';
 import { firstLine } from '../utils/string-utils.js';
 import {
   pendingThreadIDRegex,
   pendingThickSidebarURLPrefix,
   pendingSidebarURLPrefix,
 } from '../utils/validation-utils.js';
 
 function threadHasPermission(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
   permission: ThreadPermissionNotAffectedByBlock,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   invariant(
     !permissionsDisabledByBlock.has(permission) || threadInfo?.uiName,
     `${permission} can be disabled by a block, but threadHasPermission can't ` +
       'check for a block on RawThreadInfo. Please pass in ThreadInfo instead!',
   );
   if (threadInfo.minimallyEncoded) {
     return hasPermission(threadInfo.currentUser.permissions, permission);
   }
   return permissionLookup(threadInfo.currentUser.permissions, permission);
 }
 
 type CommunityRootMembersToRoleType = {
   +[threadID: ?string]: {
     +[memberID: string]: ?RoleInfo,
   },
 };
 function useCommunityRootMembersToRole(
   threadInfos: $ReadOnlyArray<RawThreadInfo | ThreadInfo>,
 ): CommunityRootMembersToRoleType {
   const communityRootMembersToRole = React.useMemo(() => {
     const communityThreadInfos = threadInfos.filter(threadInfo =>
       threadTypeIsCommunityRoot(threadInfo.type),
     );
 
     if (communityThreadInfos.length === 0) {
       return {};
     }
 
     const communityRoots = _keyBy('id')(communityThreadInfos);
     return _mapValues((threadInfo: ThreadInfo) => {
       const keyedMembers = _keyBy('id')(threadInfo.members);
       const keyedMembersToRole = _mapValues(
         (member: MemberInfoWithPermissions | RelativeMemberInfo) => {
           return member.role ? threadInfo.roles[member.role] : null;
         },
       )(keyedMembers);
       return keyedMembersToRole;
     })(communityRoots);
   }, [threadInfos]);
 
   return communityRootMembersToRole;
 }
 
 function useThreadsWithPermission(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
   permission: ThreadPermission,
 ): $ReadOnlyArray<ThreadInfo> {
   const loggedInUserInfo = useLoggedInUserInfo();
   const userInfos = useSelector(state => state.userStore.userInfos);
   const allThreadInfos = useSelector(state => state.threadStore.threadInfos);
   const allThreadInfosArray = React.useMemo(
     () => values(allThreadInfos),
     [allThreadInfos],
   );
 
   const communityRootMembersToRole =
     useCommunityRootMembersToRole(allThreadInfosArray);
 
   return React.useMemo(() => {
     return threadInfos.filter((threadInfo: ThreadInfo) => {
       const membersToRole = communityRootMembersToRole[threadInfo.id];
       const memberHasAdminRole = threadMembersWithoutAddedAdmin(
         threadInfo,
       ).some(member => roleIsAdminRole(membersToRole?.[member.id]));
 
       if (memberHasAdminRole || !loggedInUserInfo) {
         return hasPermission(threadInfo.currentUser.permissions, permission);
       }
 
       const threadFrozen = threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
         threadInfo,
         loggedInUserInfo.id,
         userInfos,
         false,
       );
 
       const permissions = threadFrozen
         ? filterOutDisabledPermissions(threadInfo.currentUser.permissions)
         : threadInfo.currentUser.permissions;
 
       return hasPermission(permissions, permission);
     });
   }, [
     threadInfos,
     communityRootMembersToRole,
     loggedInUserInfo,
     userInfos,
     permission,
   ]);
 }
 
 function useThreadHasPermission(
   threadInfo: ?ThreadInfo,
   permission: ThreadPermission,
 ): boolean {
   const threads = useThreadsWithPermission(
     threadInfo ? [threadInfo] : [],
     permission,
   );
   return threads.length === 1;
 }
 
 function viewerIsMember(
   threadInfo: ?(ThreadInfo | LegacyRawThreadInfo | RawThreadInfo),
 ): boolean {
   return !!(
     threadInfo &&
     threadInfo.currentUser.role !== null &&
     threadInfo.currentUser.role !== undefined
   );
 }
 
 function isMemberActive(
   memberInfo: MemberInfoWithPermissions | MinimallyEncodedThickMemberInfo,
 ): boolean {
   const role = memberInfo.role;
   return role !== null && role !== undefined;
 }
 
 function threadIsInHome(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadInfo.currentUser.subscription.home);
 }
 
 // Can have messages
 function threadInChatList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     viewerIsMember(threadInfo) &&
     threadHasPermission(threadInfo, threadPermissions.VISIBLE)
   );
 }
 
 function useIsThreadInChatList(threadInfo: ?ThreadInfo): boolean {
   const threadIsVisible = useThreadHasPermission(
     threadInfo,
     threadPermissions.VISIBLE,
   );
   return viewerIsMember(threadInfo) && threadIsVisible;
 }
 
 function useThreadsInChatList(
   threadInfos: $ReadOnlyArray<ThreadInfo>,
 ): $ReadOnlyArray<ThreadInfo> {
   const visibleThreads = useThreadsWithPermission(
     threadInfos,
     threadPermissions.VISIBLE,
   );
   return React.useMemo(
     () => visibleThreads.filter(viewerIsMember),
     [visibleThreads],
   );
 }
 
 function threadIsTopLevel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return threadInChatList(threadInfo) && threadIsChannel(threadInfo);
 }
 
 function threadIsChannel(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && !threadTypeIsSidebar(threadInfo.type));
 }
 
 function threadIsSidebar(threadInfo: ?(RawThreadInfo | ThreadInfo)): boolean {
   return !!(threadInfo && threadTypeIsSidebar(threadInfo.type));
 }
 
 function threadInBackgroundChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && !threadIsInHome(threadInfo);
 }
 
 function threadInHomeChatList(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
 ): boolean {
   return threadInChatList(threadInfo) && threadIsInHome(threadInfo);
 }
 
 // Can have Calendar entries,
 // does appear as a top-level entity in the thread list
 function threadInFilterList(
   threadInfo: ?(LegacyRawThreadInfo | RawThreadInfo | ThreadInfo),
 ): boolean {
   return (
     threadInChatList(threadInfo) &&
     !!threadInfo &&
     !threadTypeIsSidebar(threadInfo.type)
   );
 }
 
 function userIsMember(
   threadInfo: ?(RawThreadInfo | ThreadInfo),
   userID: string,
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   if (threadInfo.id === genesis().id) {
     return true;
   }
   return threadInfo.members.some(member => member.id === userID && member.role);
 }
 
 function threadActualMembers(
   memberInfos: $ReadOnlyArray<MemberInfoWithPermissions | RelativeMemberInfo>,
 ): $ReadOnlyArray<string> {
   return memberInfos
     .filter(memberInfo => memberInfo.role)
     .map(memberInfo => memberInfo.id);
 }
 
 type MemberIDAndRole = {
   +id: string,
   +role: ?string,
   ...
 };
 function threadOtherMembers<T: MemberIDAndRole>(
   memberInfos: $ReadOnlyArray<T>,
   viewerID: ?string,
 ): $ReadOnlyArray<T> {
   return memberInfos.filter(
     memberInfo => memberInfo.role && memberInfo.id !== viewerID,
   );
 }
 
 function threadMembersWithoutAddedAdmin<
   T: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 >(threadInfo: T): $PropertyType<T, 'members'> {
   if (threadInfo.community !== genesis().id) {
     return threadInfo.members;
   }
   const adminID = extractKeyserverIDFromIDOptional(threadInfo.id);
 
   return threadInfo.members.filter(
     member => member.id !== adminID || member.role,
   );
 }
 
 function threadIsGroupChat(threadInfo: ThreadInfo): boolean {
   return threadInfo.members.length > 2;
 }
 
 function threadOrParentThreadIsGroupChat(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
 ) {
   return threadMembersWithoutAddedAdmin(threadInfo).length > 2;
 }
 
 function threadIsPending(threadID: ?string): boolean {
   return !!threadID?.startsWith('pending');
 }
 
 function threadIsPendingSidebar(threadID: ?string): boolean {
   return (
     !!threadID?.startsWith(`pending/${pendingSidebarURLPrefix}/`) ||
     !!threadID?.startsWith(`pending/${pendingThickSidebarURLPrefix}`)
   );
 }
 
 function getSingleOtherUser(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
 ): ?string {
   if (!viewerID) {
     return undefined;
   }
   const otherMembers = threadOtherMembers(threadInfo.members, viewerID);
   if (otherMembers.length !== 1) {
     return undefined;
   }
   return otherMembers[0].id;
 }
 
 function getPendingThreadID(
   threadType: ThreadType,
   memberIDs: $ReadOnlyArray<string>,
   sourceMessageID: ?string,
 ): string {
   let pendingThreadKey;
   if (sourceMessageID && threadTypeIsThick(threadType)) {
     pendingThreadKey = `${pendingThickSidebarURLPrefix}/${sourceMessageID}`;
   } else if (sourceMessageID) {
     pendingThreadKey = `${pendingSidebarURLPrefix}/${sourceMessageID}`;
   } else {
     pendingThreadKey = [...memberIDs].sort().join('+');
   }
 
   const pendingThreadTypeString = sourceMessageID ? '' : `type${threadType}/`;
   return `pending/${pendingThreadTypeString}${pendingThreadKey}`;
 }
 
 type PendingThreadIDContents = {
   +threadType: ThreadType,
   +memberIDs: $ReadOnlyArray<string>,
   +sourceMessageID: ?string,
 };
 
 function parsePendingThreadID(
   pendingThreadID: string,
 ): ?PendingThreadIDContents {
   const pendingRegex = new RegExp(`^${pendingThreadIDRegex}$`);
   const pendingThreadIDMatches = pendingRegex.exec(pendingThreadID);
   if (!pendingThreadIDMatches) {
     return null;
   }
 
   const [threadTypeString, threadKey] = pendingThreadIDMatches[1].split('/');
   let threadType;
   if (threadTypeString === pendingThickSidebarURLPrefix) {
     threadType = threadTypes.THICK_SIDEBAR;
   } else if (threadTypeString === pendingSidebarURLPrefix) {
     threadType = threadTypes.SIDEBAR;
   } else {
     threadType = assertThreadType(Number(threadTypeString.replace('type', '')));
   }
 
   const threadTypeStringIsSidebar =
     threadTypeString === pendingSidebarURLPrefix ||
     threadTypeString === pendingThickSidebarURLPrefix;
   const memberIDs = threadTypeStringIsSidebar ? [] : threadKey.split('+');
   const sourceMessageID = threadTypeStringIsSidebar ? threadKey : null;
   return {
     threadType,
     memberIDs,
     sourceMessageID,
   };
 }
 
 type UserIDAndUsername = {
   +id: string,
   +username: ?string,
   ...
 };
 type CreatePendingThreadArgs = {
   +viewerID: string,
   +threadType: ThreadType,
   +members: $ReadOnlyArray<UserIDAndUsername>,
   +parentThreadInfo?: ?ThreadInfo,
   +threadColor?: ?string,
   +name?: ?string,
   +sourceMessageID?: string,
 };
 
 function createPendingThread({
   viewerID,
   threadType,
   members,
   parentThreadInfo,
   threadColor,
   name,
   sourceMessageID,
 }: CreatePendingThreadArgs): ThreadInfo {
   const now = Date.now();
   if (!members.some(member => member.id === viewerID)) {
     throw new Error(
       'createPendingThread should be called with the viewer as a member',
     );
   }
 
   const memberIDs = members.map(member => member.id);
   const threadID = getPendingThreadID(threadType, memberIDs, sourceMessageID);
 
   const permissions: ThreadRolePermissionsBlob = {
     [threadPermissions.KNOW_OF]: true,
     [threadPermissions.VISIBLE]: true,
     [threadPermissions.VOICED]: true,
   };
 
   const membershipPermissions = getAllThreadPermissions(
     makePermissionsBlob(permissions, null, threadID, threadType),
     threadID,
   );
   const role: RoleInfo = {
     ...minimallyEncodeRoleInfo({
       id: `${threadID}/role`,
       name: 'Members',
       permissions,
       isDefault: true,
     }),
     specialRole: specialRoles.DEFAULT_ROLE,
   };
 
   let rawThreadInfo: RawThreadInfo;
   if (threadTypeIsThick(threadType)) {
     const thickThreadType = assertThickThreadType(threadType);
     rawThreadInfo = {
       minimallyEncoded: true,
       thick: true,
       id: threadID,
       type: thickThreadType,
       name: name ?? null,
       description: null,
       color: threadColor ?? generatePendingThreadColor(memberIDs),
       creationTime: now,
       parentThreadID: parentThreadInfo?.id ?? null,
       containingThreadID: getContainingThreadID(
         parentThreadInfo,
         thickThreadType,
       ),
       members: members.map(member =>
         minimallyEncodeMemberInfo<ThickMemberInfo>({
           id: member.id,
           role: role.id,
           permissions: membershipPermissions,
           isSender: false,
           subscription: defaultThreadSubscription,
         }),
       ),
       roles: {
         [role.id]: role,
       },
       currentUser: minimallyEncodeThreadCurrentUserInfo({
         role: role.id,
         permissions: membershipPermissions,
         subscription: defaultThreadSubscription,
         unread: false,
       }),
       repliesCount: 0,
       sourceMessageID,
       pinnedCount: 0,
       timestamps: createThreadTimestamps(now, memberIDs),
     };
   } else {
     const thinThreadType = assertThinThreadType(threadType);
     rawThreadInfo = {
       minimallyEncoded: true,
       id: threadID,
       type: thinThreadType,
       name: name ?? null,
       description: null,
       color: threadColor ?? generatePendingThreadColor(memberIDs),
       creationTime: now,
       parentThreadID: parentThreadInfo?.id ?? null,
       containingThreadID: getContainingThreadID(
         parentThreadInfo,
         thinThreadType,
       ),
       community: getCommunity(parentThreadInfo),
       members: members.map(member => ({
         id: member.id,
         role: role.id,
         minimallyEncoded: true,
         isSender: false,
       })),
       roles: {
         [role.id]: role,
       },
       currentUser: minimallyEncodeThreadCurrentUserInfo({
         role: role.id,
         permissions: membershipPermissions,
         subscription: defaultThreadSubscription,
         unread: false,
       }),
       repliesCount: 0,
       sourceMessageID,
       pinnedCount: 0,
     };
   }
 
   const userInfos: { [string]: UserInfo } = {};
   for (const member of members) {
     const { id, username } = member;
     userInfos[id] = { id, username };
   }
 
   return threadInfoFromRawThreadInfo(rawThreadInfo, viewerID, userInfos);
 }
 
 type PendingPersonalThread = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo: UserInfo,
 };
 
 function createPendingPersonalOrPrivateThread(
   loggedInUserInfo: LoggedInUserInfo,
   userID: string,
   username: ?string,
   supportThickThreads: boolean,
 ): PendingPersonalThread {
   const pendingPersonalThreadUserInfo = {
     id: userID,
     username: username,
   };
 
   const members: Array<UserIDAndUsername> = [loggedInUserInfo];
   let threadType;
   if (loggedInUserInfo.id === userID) {
     threadType = supportThickThreads
       ? threadTypes.PRIVATE
       : threadTypes.GENESIS_PRIVATE;
   } else {
     threadType = supportThickThreads
       ? threadTypes.PERSONAL
       : threadTypes.GENESIS_PERSONAL;
     members.push(pendingPersonalThreadUserInfo);
   }
 
   const threadInfo = createPendingThread({
     viewerID: loggedInUserInfo.id,
     threadType,
     members,
   });
 
   return { threadInfo, pendingPersonalThreadUserInfo };
 }
 
 function createPendingThreadItem(
   loggedInUserInfo: LoggedInUserInfo,
   user: UserIDAndUsername,
   supportThickThreads: boolean,
 ): ChatThreadItem {
   const { threadInfo, pendingPersonalThreadUserInfo } =
     createPendingPersonalOrPrivateThread(
       loggedInUserInfo,
       user.id,
       user.username,
       supportThickThreads,
     );
 
   return {
     type: 'chatThreadItem',
     threadInfo,
-    mostRecentMessageInfo: null,
     mostRecentNonLocalMessage: null,
     lastUpdatedTime: threadInfo.creationTime,
     lastUpdatedTimeIncludingSidebars: threadInfo.creationTime,
     sidebars: [],
     pendingPersonalThreadUserInfo,
   };
 }
 
 // Returns map from lowercase username to AccountUserInfo
 function memberLowercaseUsernameMap(
   members: $ReadOnlyArray<RelativeMemberInfo>,
 ): Map<string, AccountUserInfo> {
   const memberMap = new Map<string, AccountUserInfo>();
   for (const member of members) {
     const { id, role, username } = member;
     if (!role || !username) {
       continue;
     }
     memberMap.set(username.toLowerCase(), { id, username });
   }
   return memberMap;
 }
 
 // Returns map from user ID to AccountUserInfo
 function extractMentionedMembers(
   text: string,
   threadInfo: ThreadInfo,
 ): Map<string, AccountUserInfo> {
   const memberMap = memberLowercaseUsernameMap(threadInfo.members);
   const mentions = extractUserMentionsFromText(text);
 
   const mentionedMembers = new Map<string, AccountUserInfo>();
   for (const mention of mentions) {
     const userInfo = memberMap.get(mention.toLowerCase());
     if (userInfo) {
       mentionedMembers.set(userInfo.id, userInfo);
     }
   }
   return mentionedMembers;
 }
 
 // When a member of the parent is mentioned in a sidebar,
 // they will be automatically added to that sidebar
 function extractNewMentionedParentMembers(
   messageText: string,
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
 ): AccountUserInfo[] {
   const mentionedMembersOfParent = extractMentionedMembers(
     messageText,
     parentThreadInfo,
   );
   for (const member of threadInfo.members) {
     if (member.role) {
       mentionedMembersOfParent.delete(member.id);
     }
   }
   return [...mentionedMembersOfParent.values()];
 }
 
 function pendingThreadType(
   numberOfOtherMembers: number,
   thickOrThin: 'thick' | 'thin',
 ): 4 | 6 | 7 | 13 | 14 | 15 {
   if (thickOrThin === 'thick') {
     if (numberOfOtherMembers === 0) {
       return threadTypes.PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.PERSONAL;
     } else {
       return threadTypes.LOCAL;
     }
   } else {
     if (numberOfOtherMembers === 0) {
       return threadTypes.GENESIS_PRIVATE;
     } else if (numberOfOtherMembers === 1) {
       return threadTypes.GENESIS_PERSONAL;
     } else {
       return threadTypes.COMMUNITY_SECRET_SUBTHREAD;
     }
   }
 }
 
 function threadTypeCanBePending(threadType: ThreadType): boolean {
   return (
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.SIDEBAR ||
     threadType === threadTypes.GENESIS_PRIVATE ||
     threadType === threadTypes.PERSONAL ||
     threadType === threadTypes.LOCAL ||
     threadType === threadTypes.THICK_SIDEBAR ||
     threadType === threadTypes.PRIVATE
   );
 }
 
 type RawThreadInfoOptions = {
   +filterThreadEditAvatarPermission?: boolean,
   +excludePinInfo?: boolean,
   +filterManageInviteLinksPermission?: boolean,
   +filterVoicedInAnnouncementChannelsPermission?: boolean,
   +minimallyEncodePermissions?: boolean,
   +includeSpecialRoleFieldInRoles?: boolean,
   +allowAddingUsersToCommunityRoot?: boolean,
   +filterManageFarcasterChannelTagsPermission?: boolean,
   +stripMemberPermissions?: boolean,
   +canDisplayFarcasterThreadAvatars?: boolean,
 };
 
 function rawThreadInfoFromServerThreadInfo(
   serverThreadInfo: ServerThreadInfo,
   viewerID: string,
   options?: RawThreadInfoOptions,
 ): ?LegacyThinRawThreadInfo | ?ThinRawThreadInfo {
   const filterThreadEditAvatarPermission =
     options?.filterThreadEditAvatarPermission;
   const excludePinInfo = options?.excludePinInfo;
   const filterManageInviteLinksPermission =
     options?.filterManageInviteLinksPermission;
   const filterVoicedInAnnouncementChannelsPermission =
     options?.filterVoicedInAnnouncementChannelsPermission;
   const shouldMinimallyEncodePermissions = options?.minimallyEncodePermissions;
   const shouldIncludeSpecialRoleFieldInRoles =
     options?.includeSpecialRoleFieldInRoles;
   const allowAddingUsersToCommunityRoot =
     options?.allowAddingUsersToCommunityRoot;
   const filterManageFarcasterChannelTagsPermission =
     options?.filterManageFarcasterChannelTagsPermission;
   const stripMemberPermissions = options?.stripMemberPermissions;
   const canDisplayFarcasterThreadAvatars =
     options?.canDisplayFarcasterThreadAvatars;
 
   const filterThreadPermissions = (
     innerThreadPermissions: ThreadPermissionsInfo,
   ) => {
     if (
       allowAddingUsersToCommunityRoot &&
       (serverThreadInfo.type === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
         serverThreadInfo.type === threadTypes.COMMUNITY_ROOT)
     ) {
       innerThreadPermissions = {
         ...innerThreadPermissions,
         [threadPermissions.ADD_MEMBERS]: {
           value: true,
           source: serverThreadInfo.id,
         },
       };
     }
     return _omitBy(
       (v, k) =>
         (filterThreadEditAvatarPermission &&
           [
             threadPermissions.EDIT_THREAD_AVATAR,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.EDIT_THREAD_AVATAR,
           ].includes(k)) ||
         (excludePinInfo &&
           [
             threadPermissions.MANAGE_PINS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissions.MANAGE_PINS,
           ].includes(k)) ||
         (filterManageInviteLinksPermission &&
           [threadPermissions.MANAGE_INVITE_LINKS].includes(k)) ||
         (filterVoicedInAnnouncementChannelsPermission &&
           [
             threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
             threadPermissionPropagationPrefixes.DESCENDANT +
               threadPermissionFilterPrefixes.TOP_LEVEL +
               threadPermissions.VOICED_IN_ANNOUNCEMENT_CHANNELS,
           ].includes(k)) ||
         (filterManageFarcasterChannelTagsPermission &&
           [threadPermissions.MANAGE_FARCASTER_CHANNEL_TAGS].includes(k)),
     )(innerThreadPermissions);
   };
 
   const members = [];
   let currentUser;
   for (const serverMember of serverThreadInfo.members) {
     if (
       serverThreadInfo.id === genesis().id &&
       serverMember.id !== viewerID &&
       serverMember.id !== ashoat.id
     ) {
       continue;
     }
 
     const memberPermissions = filterThreadPermissions(serverMember.permissions);
 
     members.push({
       id: serverMember.id,
       role: serverMember.role,
       permissions: memberPermissions,
       isSender: serverMember.isSender,
     });
     if (serverMember.id === viewerID) {
       currentUser = {
         role: serverMember.role,
         permissions: memberPermissions,
         subscription: serverMember.subscription,
         unread: serverMember.unread,
       };
     }
   }
 
   let currentUserPermissions;
   if (currentUser) {
     currentUserPermissions = currentUser.permissions;
   } else {
     currentUserPermissions = filterThreadPermissions(
       getAllThreadPermissions(null, serverThreadInfo.id),
     );
     currentUser = {
       role: null,
       permissions: currentUserPermissions,
       subscription: defaultThreadSubscription,
       unread: null,
     };
   }
   if (!permissionLookup(currentUserPermissions, threadPermissions.KNOW_OF)) {
     return null;
   }
 
   const rolesWithFilteredThreadPermissions = _mapValues(role => ({
     ...role,
     permissions: filterThreadPermissions(role.permissions),
   }))(serverThreadInfo.roles);
 
   const rolesWithoutSpecialRoleField = _mapValues(role => {
     const { specialRole, ...roleSansSpecialRole } = role;
     return roleSansSpecialRole;
   })(rolesWithFilteredThreadPermissions);
 
   let rawThreadInfo: any = {
     id: serverThreadInfo.id,
     type: serverThreadInfo.type,
     name: serverThreadInfo.name,
     description: serverThreadInfo.description,
     color: serverThreadInfo.color,
     creationTime: serverThreadInfo.creationTime,
     parentThreadID: serverThreadInfo.parentThreadID,
     members,
     roles: rolesWithoutSpecialRoleField,
     currentUser,
     repliesCount: serverThreadInfo.repliesCount,
     containingThreadID: serverThreadInfo.containingThreadID,
     community: serverThreadInfo.community,
   };
   const sourceMessageID = serverThreadInfo.sourceMessageID;
   if (sourceMessageID) {
     rawThreadInfo = { ...rawThreadInfo, sourceMessageID };
   }
   if (serverThreadInfo.avatar) {
     const avatar =
       serverThreadInfo.avatar.type === 'farcaster' &&
       !canDisplayFarcasterThreadAvatars
         ? null
         : serverThreadInfo.avatar;
     rawThreadInfo = { ...rawThreadInfo, avatar };
   }
   if (!excludePinInfo) {
     rawThreadInfo = {
       ...rawThreadInfo,
       pinnedCount: serverThreadInfo.pinnedCount,
     };
   }
 
   if (!shouldMinimallyEncodePermissions) {
     return rawThreadInfo;
   }
 
   const minimallyEncodedRawThreadInfoWithMemberPermissions =
     minimallyEncodeRawThreadInfoWithMemberPermissions(rawThreadInfo);
   invariant(
     !minimallyEncodedRawThreadInfoWithMemberPermissions.thick,
     'ServerThreadInfo should be thin thread',
   );
 
   if (!shouldIncludeSpecialRoleFieldInRoles) {
     const minimallyEncodedRolesWithoutSpecialRoleField = Object.fromEntries(
       entries(minimallyEncodedRawThreadInfoWithMemberPermissions.roles).map(
         ([key, role]) => [
           key,
           {
             ..._omit('specialRole')(role),
             isDefault: roleIsDefaultRole(role),
           },
         ],
       ),
     );
     return {
       ...minimallyEncodedRawThreadInfoWithMemberPermissions,
       roles: minimallyEncodedRolesWithoutSpecialRoleField,
     };
   }
 
   if (!stripMemberPermissions) {
     return minimallyEncodedRawThreadInfoWithMemberPermissions;
   }
 
   // The return value of `deprecatedMinimallyEncodeRawThreadInfo` is typed
   // as `RawThreadInfo`, but still includes thread member permissions.
   // This was to prevent introducing "Legacy" types that would need to be
   // maintained going forward. This `any`-cast allows us to more precisely
   // type the obj being passed to `stripMemberPermissionsFromRawThreadInfo`.
   const rawThreadInfoWithMemberPermissions: ThinRawThreadInfoWithPermissions =
     (minimallyEncodedRawThreadInfoWithMemberPermissions: any);
 
   return stripMemberPermissionsFromRawThreadInfo(
     rawThreadInfoWithMemberPermissions,
   );
 }
 
 function threadUIName(threadInfo: ThreadInfo): string | ThreadEntity {
   if (threadInfo.name) {
     return firstLine(threadInfo.name);
   }
 
   const threadMembers: $ReadOnlyArray<RelativeMemberInfo> =
     threadInfo.members.filter(memberInfo => memberInfo.role);
   const memberEntities: $ReadOnlyArray<UserEntity> = threadMembers.map(member =>
     ET.user({ userInfo: member }),
   );
 
   return {
     type: 'thread',
     id: threadInfo.id,
     name: threadInfo.name,
     display: 'uiName',
     uiName: memberEntities,
     ifJustViewer: threadTypeIsPrivate(threadInfo.type)
       ? 'viewer_username'
       : 'just_you_string',
   };
 }
 
 function threadInfoFromRawThreadInfo(
   rawThreadInfo: RawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): ThreadInfo {
   let threadInfo: ThreadInfo = {
     minimallyEncoded: true,
     id: rawThreadInfo.id,
     type: rawThreadInfo.type,
     name: rawThreadInfo.name,
     uiName: '',
     description: rawThreadInfo.description,
     color: rawThreadInfo.color,
     creationTime: rawThreadInfo.creationTime,
     parentThreadID: rawThreadInfo.parentThreadID,
     containingThreadID: rawThreadInfo.containingThreadID,
     community: rawThreadInfo.community,
     members: getRelativeMemberInfos(rawThreadInfo, viewerID, userInfos),
     roles: rawThreadInfo.roles,
     currentUser: rawThreadInfo.currentUser,
     repliesCount: rawThreadInfo.repliesCount,
   };
 
   threadInfo = {
     ...threadInfo,
     uiName: threadUIName(threadInfo),
   };
   const { sourceMessageID, avatar, pinnedCount } = rawThreadInfo;
   if (sourceMessageID) {
     threadInfo = { ...threadInfo, sourceMessageID };
   }
 
   if (avatar) {
     threadInfo = { ...threadInfo, avatar };
   } else if (
     threadTypeIsPrivate(rawThreadInfo.type) ||
     threadTypeIsPersonal(rawThreadInfo.type)
   ) {
     threadInfo = {
       ...threadInfo,
       avatar: getUserAvatarForThread(rawThreadInfo, viewerID, userInfos),
     };
   }
 
   if (pinnedCount) {
     threadInfo = { ...threadInfo, pinnedCount };
   }
   return threadInfo;
 }
 
 function filterOutDisabledPermissions(permissionsBitmask: string): string {
   const decodedPermissions: ThreadPermissionsInfo =
     threadPermissionsFromBitmaskHex(permissionsBitmask);
   const updatedPermissions = { ...decodedPermissions, ...disabledPermissions };
   const encodedUpdatedPermissions: string =
     permissionsToBitmaskHex(updatedPermissions);
   return encodedUpdatedPermissions;
 }
 
 function baseThreadIsWithBlockedUserOnly(
   threadInfo: LegacyRawThreadInfo | RawThreadInfo | ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ) {
   const otherUserID = getSingleOtherUser(threadInfo, viewerID);
   if (!otherUserID) {
     return false;
   }
   const otherUserRelationshipStatus =
     userInfos[otherUserID]?.relationshipStatus;
 
   if (checkOnlyViewerBlock) {
     return (
       otherUserRelationshipStatus === userRelationshipStatus.BLOCKED_BY_VIEWER
     );
   }
 
   return (
     !!otherUserRelationshipStatus &&
     relationshipBlockedInEitherDirection(otherUserRelationshipStatus)
   );
 }
 
 function threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
   threadInfo: ThreadInfo | RawThreadInfo | LegacyRawThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
   checkOnlyViewerBlock: boolean,
 ): boolean {
   if (threadOrParentThreadIsGroupChat(threadInfo)) {
     return false;
   }
   return baseThreadIsWithBlockedUserOnly(
     threadInfo,
     viewerID,
     userInfos,
     checkOnlyViewerBlock,
   );
 }
 
 function useThreadFrozenDueToViewerBlock(
   threadInfo: ThreadInfo,
   communityThreadInfo: ?ThreadInfo,
   viewerID: ?string,
   userInfos: UserInfos,
 ): boolean {
   const communityThreadInfoArray = React.useMemo(
     () => (communityThreadInfo ? [communityThreadInfo] : []),
     [communityThreadInfo],
   );
   const communityRootsMembersToRole = useCommunityRootMembersToRole(
     communityThreadInfoArray,
   );
   const memberToRole = communityRootsMembersToRole[communityThreadInfo?.id];
 
   const memberHasAdminRole = threadMembersWithoutAddedAdmin(threadInfo).some(
     m => roleIsAdminRole(memberToRole?.[m.id]),
   );
 
   return React.useMemo(() => {
     if (memberHasAdminRole) {
       return false;
     }
 
     return threadIsWithBlockedUserOnlyWithoutAdminRoleCheck(
       threadInfo,
       viewerID,
       userInfos,
       true,
     );
   }, [memberHasAdminRole, threadInfo, userInfos, viewerID]);
 }
 
 const threadTypeDescriptions: { [ThreadType]: string } = {
   [threadTypes.COMMUNITY_OPEN_SUBTHREAD]:
     'Anybody in the parent channel can see an open subchannel.',
   [threadTypes.COMMUNITY_SECRET_SUBTHREAD]:
     'Only visible to its members and admins of ancestor channels.',
 };
 
 function roleIsDefaultRole(
   roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo,
 ): boolean {
   if (roleInfo?.specialRole === specialRoles.DEFAULT_ROLE) {
     return true;
   }
   return !!(roleInfo && roleInfo.isDefault);
 }
 
 function roleIsAdminRole(roleInfo: ?ClientLegacyRoleInfo | ?RoleInfo): boolean {
   if (roleInfo?.specialRole === specialRoles.ADMIN_ROLE) {
     return true;
   }
   return !!(roleInfo && !roleInfo.isDefault && roleInfo.name === 'Admins');
 }
 
 function threadHasAdminRole(
   threadInfo: ?(
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo
     | ServerThreadInfo
   ),
 ): boolean {
   if (!threadInfo) {
     return false;
   }
   let hasSpecialRoleFieldBeenEncountered = false;
   for (const role of Object.values(threadInfo.roles)) {
     if (role.specialRole === specialRoles.ADMIN_ROLE) {
       return true;
     }
     if (role.specialRole !== undefined) {
       hasSpecialRoleFieldBeenEncountered = true;
     }
   }
   if (hasSpecialRoleFieldBeenEncountered) {
     return false;
   }
   return !!_find({ name: 'Admins' })(threadInfo.roles);
 }
 
 function identifyInvalidatedThreads(
   updateInfos: $ReadOnlyArray<ClientUpdateInfo>,
 ): Set<string> {
   const invalidated = new Set<string>();
   for (const updateInfo of updateInfos) {
     if (updateInfo.type === updateTypes.DELETE_THREAD) {
       invalidated.add(updateInfo.threadID);
     }
   }
   return invalidated;
 }
 
 const permissionsDisabledByBlockArray = values(
   threadPermissionsDisabledByBlock,
 );
 
 const permissionsDisabledByBlock: Set<ThreadPermission> = new Set(
   permissionsDisabledByBlockArray,
 );
 
 const disabledPermissions: ThreadPermissionsInfo =
   permissionsDisabledByBlockArray.reduce(
     (permissions: ThreadPermissionsInfo, permission: string) => ({
       ...permissions,
       [permission]: { value: false, source: null },
     }),
     {},
   );
 
 // Consider updating itemHeight in native/chat/chat-thread-list.react.js
 // if you change this
 const emptyItemText: string =
   `Muted chats are just like normal chats, except they don't ` +
   `contribute to your unread count.\n\n` +
   `To move a chat over here, switch the “Muted” option in its settings.`;
 
 function threadNoun(threadType: ThreadType, parentThreadID: ?string): string {
   if (threadTypeIsSidebar(threadType)) {
     return 'thread';
   } else if (
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD &&
     parentThreadID === genesis().id
   ) {
     return 'chat';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadType === threadTypes.GENESIS
   ) {
     return 'channel';
   } else {
     return 'chat';
   }
 }
 
 function threadLabel(threadType: ThreadType): string {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD
   ) {
     return 'Open';
   } else if (threadType === threadTypes.GENESIS_PERSONAL) {
     return 'Personal';
   } else if (threadTypeIsSidebar(threadType)) {
     return 'Thread';
   } else if (threadType === threadTypes.GENESIS_PRIVATE) {
     return 'Private';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS
   ) {
     return 'Community';
   } else if (threadTypeIsThick(threadType)) {
     return 'Local DM';
   } else {
     return 'Secret';
   }
 }
 
 type ExistingThreadInfoFinderParams = {
   +searching: boolean,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
   +allUsersSupportThickThreads: boolean,
 };
 type ExistingThreadInfoFinder = (
   params: ExistingThreadInfoFinderParams,
 ) => ?ThreadInfo;
 
 function useExistingThreadInfoFinder(
   baseThreadInfo: ?ThreadInfo,
 ): ExistingThreadInfoFinder {
   const threadInfos = useSelector(threadInfoSelector);
   const loggedInUserInfo = useLoggedInUserInfo();
 
   const pendingToRealizedThreadIDs = useSelector(state =>
     pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
   );
   return React.useCallback(
     (params: ExistingThreadInfoFinderParams): ?ThreadInfo => {
       if (!baseThreadInfo) {
         return null;
       }
 
       const realizedThreadInfo = threadInfos[baseThreadInfo.id];
       if (realizedThreadInfo) {
         return realizedThreadInfo;
       }
 
       if (!loggedInUserInfo || !threadIsPending(baseThreadInfo.id)) {
         return baseThreadInfo;
       }
       const viewerID = loggedInUserInfo?.id;
 
       invariant(
         threadTypeCanBePending(baseThreadInfo.type),
         `ThreadInfo has pending ID ${baseThreadInfo.id}, but type that ` +
           `should not be pending ${baseThreadInfo.type}`,
       );
 
       const { searching, userInfoInputArray } = params;
 
       const { sourceMessageID } = baseThreadInfo;
 
       let pendingThreadID;
       if (searching) {
         pendingThreadID = getPendingThreadID(
           pendingThreadType(userInfoInputArray.length, 'thick'),
           [...userInfoInputArray.map(user => user.id), viewerID],
           sourceMessageID,
         );
       } else {
         pendingThreadID = getPendingThreadID(
           baseThreadInfo.type,
           baseThreadInfo.members.map(member => member.id),
           sourceMessageID,
         );
       }
       const realizedThreadID = pendingToRealizedThreadIDs.get(pendingThreadID);
       if (realizedThreadID && threadInfos[realizedThreadID]) {
         return threadInfos[realizedThreadID];
       }
 
       if (!searching) {
         return baseThreadInfo;
       }
 
       return createPendingThread({
         viewerID,
         threadType: pendingThreadType(
           userInfoInputArray.length,
           params.allUsersSupportThickThreads ? 'thick' : 'thin',
         ),
         members: [
           { ...loggedInUserInfo, isViewer: true },
           ...userInfoInputArray,
         ],
       });
     },
     [baseThreadInfo, threadInfos, loggedInUserInfo, pendingToRealizedThreadIDs],
   );
 }
 
 type ThreadTypeParentRequirement = 'optional' | 'required' | 'disabled';
 
 function getThreadTypeParentRequirement(
   threadType: ThinThreadType,
 ): ThreadTypeParentRequirement {
   if (
     threadType === threadTypes.COMMUNITY_OPEN_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD ||
     //threadType === threadTypes.COMMUNITY_SECRET_SUBTHREAD ||
     threadType === threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD ||
     threadTypeIsSidebar(threadType)
   ) {
     return 'required';
   } else if (
     threadType === threadTypes.COMMUNITY_ROOT ||
     threadType === threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT ||
     threadType === threadTypes.GENESIS ||
     threadType === threadTypes.GENESIS_PERSONAL ||
     threadType === threadTypes.GENESIS_PRIVATE
   ) {
     return 'disabled';
   } else {
     return 'optional';
   }
 }
 
 function checkIfDefaultMembersAreVoiced(threadInfo: ThreadInfo): boolean {
   const defaultRoleID = Object.keys(threadInfo.roles).find(roleID =>
     roleIsDefaultRole(threadInfo.roles[roleID]),
   );
   invariant(
     defaultRoleID !== undefined,
     'all threads should have a default role',
   );
   const defaultRole = threadInfo.roles[defaultRoleID];
   const defaultRolePermissions =
     decodeMinimallyEncodedRoleInfo(defaultRole).permissions;
 
   return !!defaultRolePermissions[threadPermissions.VOICED];
 }
 
 const draftKeySuffix = '/message_composer';
 
 function draftKeyFromThreadID(threadID: string): string {
   return `${threadID}${draftKeySuffix}`;
 }
 
 function getContainingThreadID(
   parentThreadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
   threadType: ThreadType,
 ): ?string {
   if (!parentThreadInfo) {
     return null;
   }
   if (threadTypeIsSidebar(threadType)) {
     return parentThreadInfo.id;
   }
   if (!parentThreadInfo.containingThreadID) {
     return parentThreadInfo.id;
   }
   return parentThreadInfo.containingThreadID;
 }
 
 function getCommunity(
   threadInfo:
     | ?ServerThreadInfo
     | LegacyRawThreadInfo
     | RawThreadInfo
     | ThreadInfo,
 ): ?string {
   if (!threadInfo) {
     return null;
   }
   const { id, community, type } = threadInfo;
   if (community !== null && community !== undefined) {
     return community;
   }
   if (threadTypeIsCommunityRoot(type)) {
     return id;
   }
   return null;
 }
 
 function getSearchResultsForEmptySearchText(
   chatListData: $ReadOnlyArray<ChatThreadItem>,
   threadFilter: ThreadInfo => boolean,
 ): Array<ChatThreadItem> {
   const threadHomeSubscriptions = Object.fromEntries(
     chatListData.map(chatThreadItem => [
       chatThreadItem.threadInfo.id,
       threadIsInHome(chatThreadItem.threadInfo),
     ]),
   );
 
   return chatListData
     .filter((item: ChatThreadItem) => {
       const { threadInfo } = item;
       const { parentThreadID } = threadInfo;
       const isInFilteredChatList =
         threadInChatList(threadInfo) && threadFilter(threadInfo);
 
       if (!isInFilteredChatList) {
         return false;
       }
       if (!threadIsSidebar(threadInfo) || !parentThreadID) {
         return true;
       }
       const isParentInHome = threadHomeSubscriptions[parentThreadID];
       const isThreadInHome = threadIsInHome(threadInfo);
 
       return isParentInHome !== isThreadInHome;
     })
     .map((item: ChatThreadItem) => {
       if (threadIsSidebar(item.threadInfo)) {
         return item;
       }
       const sidebarsOnlyInSameTab = item.sidebars.filter(
         (sidebar: SidebarItem) =>
           sidebar.type !== 'sidebar' ||
           threadIsInHome(sidebar.threadInfo) ===
             threadIsInHome(item.threadInfo),
       );
       return {
         ...item,
         sidebars: sidebarsOnlyInSameTab,
       };
     });
 }
 
 function getThreadListSearchResults(
   chatListData: $ReadOnlyArray<ChatThreadItem>,
   searchText: string,
   threadFilter: ThreadInfo => boolean,
   threadSearchResults: $ReadOnlySet<string>,
   usersSearchResults: $ReadOnlyArray<UserSearchResult>,
   loggedInUserInfo: ?LoggedInUserInfo,
 ): $ReadOnlyArray<ChatThreadItem> {
   if (!searchText) {
     return getSearchResultsForEmptySearchText(chatListData, threadFilter);
   }
 
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   for (const item of chatListData) {
     if (!threadSearchResults.has(item.threadInfo.id)) {
       continue;
     }
     if (threadTypeIsPrivate(item.threadInfo.type)) {
       privateThreads.push({ ...item, sidebars: [] });
     } else if (threadTypeIsPersonal(item.threadInfo.type)) {
       personalThreads.push({ ...item, sidebars: [] });
     } else {
       otherThreads.push({ ...item, sidebars: [] });
     }
   }
 
   const chatItems: ChatThreadItem[] = [
     ...privateThreads,
     ...personalThreads,
     ...otherThreads,
   ];
   if (loggedInUserInfo) {
     chatItems.push(
       ...usersSearchResults.map(user =>
         createPendingThreadItem(
           loggedInUserInfo,
           user,
           user.supportThickThreads,
         ),
       ),
     );
   }
   return chatItems;
 }
 
 function reorderThreadSearchResults<T: RawThreadInfo | ThreadInfo>(
   threadInfos: $ReadOnlyArray<T>,
   threadSearchResults: $ReadOnlyArray<string>,
 ): T[] {
   const privateThreads = [];
   const personalThreads = [];
   const otherThreads = [];
   const threadSearchResultsSet = new Set(threadSearchResults);
   for (const threadInfo of threadInfos) {
     if (!threadSearchResultsSet.has(threadInfo.id)) {
       continue;
     }
     if (threadTypeIsPrivate(threadInfo.type)) {
       privateThreads.push(threadInfo);
     } else if (threadTypeIsPersonal(threadInfo.type)) {
       personalThreads.push(threadInfo);
     } else {
       otherThreads.push(threadInfo);
     }
   }
 
   return [...privateThreads, ...personalThreads, ...otherThreads];
 }
 
 function useAvailableThreadMemberActions(
   memberInfo: RelativeMemberInfo,
   threadInfo: ThreadInfo,
   canEdit: ?boolean = true,
 ): $ReadOnlyArray<'change_role' | 'remove_user'> {
   const canRemoveMembers = useThreadHasPermission(
     threadInfo,
     threadPermissions.REMOVE_MEMBERS,
   );
   const canChangeRoles = useThreadHasPermission(
     threadInfo,
     threadPermissions.CHANGE_ROLE,
   );
 
   return React.useMemo(() => {
     const { role } = memberInfo;
     if (!canEdit || !role) {
       return [];
     }
 
     const result = [];
 
     if (
       canChangeRoles &&
       memberInfo.username &&
       threadHasAdminRole(threadInfo)
     ) {
       result.push('change_role');
     }
 
     if (
       canRemoveMembers &&
       !memberInfo.isViewer &&
       (canChangeRoles || roleIsDefaultRole(threadInfo.roles[role]))
     ) {
       result.push('remove_user');
     }
 
     return result;
   }, [canChangeRoles, canEdit, canRemoveMembers, memberInfo, threadInfo]);
 }
 
 function patchThreadInfoToIncludeMentionedMembersOfParent(
   threadInfo: ThreadInfo,
   parentThreadInfo: ThreadInfo,
   messageText: string,
   viewerID: string,
 ): ThreadInfo {
   const members: UserIDAndUsername[] = threadInfo.members
     .map(({ id, username }) =>
       username ? ({ id, username }: UserIDAndUsername) : null,
     )
     .filter(Boolean);
   const mentionedNewMembers = extractNewMentionedParentMembers(
     messageText,
     threadInfo,
     parentThreadInfo,
   );
   if (mentionedNewMembers.length === 0) {
     return threadInfo;
   }
   members.push(...mentionedNewMembers);
   const threadType = threadTypeIsThick(parentThreadInfo.type)
     ? threadTypes.THICK_SIDEBAR
     : threadTypes.SIDEBAR;
 
   return createPendingThread({
     viewerID,
     threadType,
     members,
     parentThreadInfo,
     threadColor: threadInfo.color,
     name: threadInfo.name,
     sourceMessageID: threadInfo.sourceMessageID,
   });
 }
 
 function threadInfoInsideCommunity(
   threadInfo: RawThreadInfo | ThreadInfo,
   communityID: string,
 ): boolean {
   return threadInfo.community === communityID || threadInfo.id === communityID;
 }
 
 type RoleAndMemberCount = {
   [roleName: string]: number,
 };
 
 function useRoleMemberCountsForCommunity(
   threadInfo: ThreadInfo,
 ): RoleAndMemberCount {
   return React.useMemo(() => {
     const roleIDsToNames: { [string]: string } = {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       roleIDsToNames[roleID] = threadInfo.roles[roleID].name;
     });
 
     const roleNamesToMemberCount: RoleAndMemberCount = {};
 
     threadInfo.members.forEach(({ role: roleID }) => {
       invariant(roleID, 'Community member should have a role');
       const roleName = roleIDsToNames[roleID];
 
       roleNamesToMemberCount[roleName] =
         (roleNamesToMemberCount[roleName] ?? 0) + 1;
     });
 
     // For all community roles with no members, add them to the list with 0
     Object.keys(roleIDsToNames).forEach(roleName => {
       if (roleNamesToMemberCount[roleIDsToNames[roleName]] === undefined) {
         roleNamesToMemberCount[roleIDsToNames[roleName]] = 0;
       }
     });
 
     return roleNamesToMemberCount;
   }, [threadInfo.members, threadInfo.roles]);
 }
 
 function useRoleNamesToSpecialRole(threadInfo: ThreadInfo): {
   +[roleName: string]: ?SpecialRole,
 } {
   return React.useMemo(() => {
     const roleNamesToSpecialRole: { [roleName: string]: ?SpecialRole } = {};
     values(threadInfo.roles).forEach(role => {
       if (roleNamesToSpecialRole[role.name] !== undefined) {
         return;
       }
       if (roleIsDefaultRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.DEFAULT_ROLE;
       } else if (roleIsAdminRole(role)) {
         roleNamesToSpecialRole[role.name] = specialRoles.ADMIN_ROLE;
       } else {
         roleNamesToSpecialRole[role.name] = null;
       }
     });
     return roleNamesToSpecialRole;
   }, [threadInfo.roles]);
 }
 
 type RoleUserSurfacedPermissions = {
   +[roleName: string]: $ReadOnlySet<UserSurfacedPermission>,
 };
 // Iterates through the existing roles in the community and 'reverse maps'
 // the set of permission literals for each role to user-facing permission enums
 // to help pre-populate the permission checkboxes when editing roles.
 function useRoleUserSurfacedPermissions(
   threadInfo: ThreadInfo,
 ): RoleUserSurfacedPermissions {
   return React.useMemo(() => {
     const roleNamesToPermissions: { [string]: Set<UserSurfacedPermission> } =
       {};
 
     Object.keys(threadInfo.roles).forEach(roleID => {
       const roleName = threadInfo.roles[roleID].name;
       const rolePermissions = decodeMinimallyEncodedRoleInfo(
         threadInfo.roles[roleID],
       ).permissions;
       roleNamesToPermissions[roleName] =
         userSurfacedPermissionsFromRolePermissions(rolePermissions);
     });
 
     return roleNamesToPermissions;
   }, [threadInfo.roles]);
 }
 
 function communityOrThreadNoun(threadInfo: RawThreadInfo | ThreadInfo): string {
   return threadTypeIsCommunityRoot(threadInfo.type)
     ? 'community'
     : threadNoun(threadInfo.type, threadInfo.parentThreadID);
 }
 
 function getThreadsToDeleteText(
   threadInfo: RawThreadInfo | ThreadInfo,
 ): string {
   return `${
     threadTypeIsCommunityRoot(threadInfo.type)
       ? 'Subchannels and threads'
       : 'Threads'
   } within this ${communityOrThreadNoun(threadInfo)}`;
 }
 
 type OldestCreatedInput = { +creationTime: number, ... };
 function getOldestCreated<T: OldestCreatedInput>(arr: $ReadOnlyArray<T>): ?T {
   return arr.reduce<?T>(
     (a, b) => (!b || (a && a.creationTime < b.creationTime) ? a : b),
     null,
   );
 }
 
 function useOldestPrivateThreadInfo(): ?ThreadInfo {
   const genesisPrivateThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PRIVATE,
   );
   const genesisPrivateThreadInfos = useSelector(
     genesisPrivateThreadInfosSelector,
   );
   const privateThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.PRIVATE,
   );
   const privateThreadInfos = useSelector(privateThreadInfosSelector);
   return React.useMemo(
     () =>
       getOldestCreated([...privateThreadInfos, ...genesisPrivateThreadInfos]),
     [privateThreadInfos, genesisPrivateThreadInfos],
   );
 }
 
 function useUserProfileThreadInfo(userInfo: ?UserInfo): ?UserProfileThreadInfo {
   const userID = userInfo?.id;
   const username = userInfo?.username;
 
   const loggedInUserInfo = useLoggedInUserInfo();
   const isViewerProfile = loggedInUserInfo?.id === userID;
 
   const oldestPrivateThreadInfo = useOldestPrivateThreadInfo();
 
   const usersWithPersonalThread = useSelector(usersWithPersonalThreadSelector);
   const genesisPersonalThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.GENESIS_PERSONAL,
   );
   const genesisPersonalThreadInfos = useSelector(
     genesisPersonalThreadInfosSelector,
   );
   const personalThreadInfosSelector = threadInfosSelectorForThreadType(
     threadTypes.PERSONAL,
   );
   const personalThreadInfos = useSelector(personalThreadInfosSelector);
   const allPersonalThreadInfos = React.useMemo(
     () => [...personalThreadInfos, ...genesisPersonalThreadInfos],
     [personalThreadInfos, genesisPersonalThreadInfos],
   );
 
   const [supportThickThreads, setSupportThickThreads] = React.useState(false);
   const usersSupportThickThreads = useUsersSupportThickThreads();
 
   React.useEffect(() => {
     void (async () => {
       if (!userInfo) {
         setSupportThickThreads(false);
         return;
       }
       const result = await usersSupportThickThreads([userInfo.id]);
       setSupportThickThreads(result.has(userInfo.id));
     })();
   }, [userInfo, usersSupportThickThreads]);
 
   return React.useMemo(() => {
     if (!loggedInUserInfo || !userID || !username) {
       return null;
     }
 
     if (isViewerProfile && oldestPrivateThreadInfo) {
       return { threadInfo: oldestPrivateThreadInfo };
     }
 
     if (usersWithPersonalThread.has(userID)) {
       const personalThreadInfo: ?ThreadInfo = getOldestCreated(
         allPersonalThreadInfos.filter(
           threadInfo =>
             userID === getSingleOtherUser(threadInfo, loggedInUserInfo.id),
         ),
       );
       return personalThreadInfo ? { threadInfo: personalThreadInfo } : null;
     }
 
     const pendingPersonalThreadInfo = createPendingPersonalOrPrivateThread(
       loggedInUserInfo,
       userID,
       username,
       supportThickThreads,
     );
 
     return pendingPersonalThreadInfo;
   }, [
     isViewerProfile,
     loggedInUserInfo,
     allPersonalThreadInfos,
     oldestPrivateThreadInfo,
     supportThickThreads,
     userID,
     username,
     usersWithPersonalThread,
   ]);
 }
 
 function assertAllThreadInfosAreLegacy(rawThreadInfos: MixedRawThreadInfos): {
   [id: string]: LegacyRawThreadInfo,
 } {
   return Object.fromEntries(
     Object.entries(rawThreadInfos).map(([id, rawThreadInfo]) => {
       invariant(
         !rawThreadInfo.minimallyEncoded,
         `rawThreadInfos shouldn't be minimallyEncoded`,
       );
       return [id, rawThreadInfo];
     }),
   );
 }
 
 function useOnScreenEntryEditableThreadInfos(): $ReadOnlyArray<ThreadInfo> {
   const visibleThreadInfos = useSelector(onScreenThreadInfos);
   const editableVisibleThreadInfos = useThreadsWithPermission(
     visibleThreadInfos,
     threadPermissions.EDIT_ENTRIES,
   );
   return editableVisibleThreadInfos;
 }
 
 function createThreadTimestamps(
   timestamp: number,
   memberIDs: $ReadOnlyArray<string>,
 ): ThreadTimestamps {
   return {
     name: timestamp,
     avatar: timestamp,
     description: timestamp,
     color: timestamp,
     members: Object.fromEntries(
       memberIDs.map(id => [
         id,
         { isMember: timestamp, subscription: timestamp },
       ]),
     ),
     currentUser: {
       unread: timestamp,
     },
   };
 }
 
 function userHasDeviceList(
   userID: string,
   auxUserInfos: AuxUserInfos,
 ): boolean {
   return deviceListIsNonEmpty(auxUserInfos[userID]?.deviceList);
 }
 
 function deviceListIsNonEmpty(deviceList?: RawDeviceList): boolean {
   return !!deviceList && deviceList.devices.length > 0;
 }
 
 const deviceListRequestTimeout = 20 * 1000; // twenty seconds
 const expectedAccountDeletionUpdateTimeout = 24 * 60 * 60 * 1000; // one day
 
 function deviceListCanBeRequestedForUser(
   userID: string,
   auxUserInfos: AuxUserInfos,
 ): boolean {
   return (
     !auxUserInfos[userID]?.accountMissingStatus ||
     auxUserInfos[userID].accountMissingStatus.lastChecked <
       Date.now() - deviceListRequestTimeout
   );
 }
 
 export {
   threadHasPermission,
   useCommunityRootMembersToRole,
   useThreadHasPermission,
   viewerIsMember,
   threadInChatList,
   useIsThreadInChatList,
   useThreadsInChatList,
   threadIsTopLevel,
   threadIsChannel,
   threadIsSidebar,
   threadInBackgroundChatList,
   threadInHomeChatList,
   threadIsInHome,
   threadInFilterList,
   userIsMember,
   threadActualMembers,
   threadOtherMembers,
   threadIsGroupChat,
   threadIsPending,
   threadIsPendingSidebar,
   getSingleOtherUser,
   getPendingThreadID,
   parsePendingThreadID,
   createPendingThread,
   extractNewMentionedParentMembers,
   pendingThreadType,
   filterOutDisabledPermissions,
   useThreadFrozenDueToViewerBlock,
   rawThreadInfoFromServerThreadInfo,
   threadUIName,
   threadInfoFromRawThreadInfo,
   threadTypeDescriptions,
   threadIsWithBlockedUserOnlyWithoutAdminRoleCheck,
   roleIsDefaultRole,
   roleIsAdminRole,
   threadHasAdminRole,
   identifyInvalidatedThreads,
   permissionsDisabledByBlock,
   emptyItemText,
   threadNoun,
   threadLabel,
   useExistingThreadInfoFinder,
   getThreadTypeParentRequirement,
   checkIfDefaultMembersAreVoiced,
   draftKeySuffix,
   draftKeyFromThreadID,
   threadTypeCanBePending,
   getContainingThreadID,
   getCommunity,
   getThreadListSearchResults,
   reorderThreadSearchResults,
   useAvailableThreadMemberActions,
   threadMembersWithoutAddedAdmin,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   useRoleMemberCountsForCommunity,
   useRoleNamesToSpecialRole,
   useRoleUserSurfacedPermissions,
   getThreadsToDeleteText,
   useOldestPrivateThreadInfo,
   useUserProfileThreadInfo,
   assertAllThreadInfosAreLegacy,
   useOnScreenEntryEditableThreadInfos,
   extractMentionedMembers,
   isMemberActive,
   createThreadTimestamps,
   userHasDeviceList,
   deviceListIsNonEmpty,
   deviceListCanBeRequestedForUser,
   expectedAccountDeletionUpdateTimeout,
 };
diff --git a/native/chat/chat-thread-list-item.react.js b/native/chat/chat-thread-list-item.react.js
index 7ed332645..420ea6fac 100644
--- a/native/chat/chat-thread-list-item.react.js
+++ b/native/chat/chat-thread-list-item.react.js
@@ -1,308 +1,304 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import type { ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
 import type { UserInfo } from 'lib/types/user-types.js';
 import { shortAbsoluteDate } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import ChatThreadListSeeMoreSidebars from './chat-thread-list-see-more-sidebars.react.js';
 import ChatThreadListSidebar from './chat-thread-list-sidebar.react.js';
 import MessagePreview from './message-preview.react.js';
 import SwipeableThread from './swipeable-thread.react.js';
 import ThreadAvatar from '../avatars/thread-avatar.react.js';
 import Button from '../components/button.react.js';
 import SingleLine from '../components/single-line.react.js';
 import ThreadAncestorsLabel from '../components/thread-ancestors-label.react.js';
 import UnreadDot from '../components/unread-dot.react.js';
 import { useColors, useStyles } from '../themes/colors.js';
 
 type Props = {
   +data: ChatThreadItem,
   +onPressItem: (
     threadInfo: ThreadInfo,
     pendingPersonalThreadUserInfo?: UserInfo,
   ) => void,
   +onPressSeeMoreSidebars: (threadInfo: ThreadInfo) => void,
   +onSwipeableWillOpen: (threadInfo: ThreadInfo) => void,
   +currentlyOpenedSwipeableId: string,
 };
 function ChatThreadListItem({
   data,
   onPressItem,
   onPressSeeMoreSidebars,
   onSwipeableWillOpen,
   currentlyOpenedSwipeableId,
 }: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const colors = useColors();
 
   const numOfSidebarsWithExtendedArrow =
     data.sidebars.filter(sidebarItem => sidebarItem.type === 'sidebar').length -
     1;
 
   const sidebars = React.useMemo(
     () =>
       data.sidebars.map((sidebarItem, index) => {
         if (sidebarItem.type === 'sidebar') {
           const { type, ...sidebarInfo } = sidebarItem;
           return (
             <ChatThreadListSidebar
               sidebarInfo={sidebarInfo}
               onPressItem={onPressItem}
               onSwipeableWillOpen={onSwipeableWillOpen}
               currentlyOpenedSwipeableId={currentlyOpenedSwipeableId}
               key={sidebarItem.threadInfo.id}
               extendArrow={index < numOfSidebarsWithExtendedArrow}
             />
           );
         } else if (sidebarItem.type === 'seeMore') {
           return (
             <ChatThreadListSeeMoreSidebars
               threadInfo={data.threadInfo}
               unread={sidebarItem.unread}
               onPress={onPressSeeMoreSidebars}
               key="seeMore"
             />
           );
         } else {
           return <View style={styles.spacer} key="spacer" />;
         }
       }),
     [
       currentlyOpenedSwipeableId,
       data.sidebars,
       data.threadInfo,
       numOfSidebarsWithExtendedArrow,
       onPressItem,
       onPressSeeMoreSidebars,
       onSwipeableWillOpen,
       styles.spacer,
     ],
   );
 
   const onPress = React.useCallback(() => {
     onPressItem(data.threadInfo, data.pendingPersonalThreadUserInfo);
   }, [onPressItem, data.threadInfo, data.pendingPersonalThreadUserInfo]);
 
   const threadNameStyle = React.useMemo(() => {
     if (!data.threadInfo.currentUser.unread) {
       return styles.threadName;
     }
     return [styles.threadName, styles.unreadThreadName];
   }, [
     data.threadInfo.currentUser.unread,
     styles.threadName,
     styles.unreadThreadName,
   ]);
 
   const lastActivity = shortAbsoluteDate(data.lastUpdatedTime);
   const lastActivityStyle = React.useMemo(() => {
     if (!data.threadInfo.currentUser.unread) {
       return styles.lastActivity;
     }
     return [styles.lastActivity, styles.unreadLastActivity];
   }, [
     data.threadInfo.currentUser.unread,
     styles.lastActivity,
     styles.unreadLastActivity,
   ]);
 
   const resolvedThreadInfo = useResolvedThreadInfo(data.threadInfo);
 
   const unreadDot = React.useMemo(
     () => (
       <View style={styles.avatarContainer}>
         <UnreadDot unread={data.threadInfo.currentUser.unread} />
       </View>
     ),
     [data.threadInfo.currentUser.unread, styles.avatarContainer],
   );
 
   const threadAvatar = React.useMemo(
     () => (
       <View style={styles.avatarContainer}>
         <ThreadAvatar size="M" threadInfo={data.threadInfo} />
       </View>
     ),
     [data.threadInfo, styles.avatarContainer],
   );
 
   const isThick = threadTypeIsThick(data.threadInfo.type);
   const iconStyle = data.threadInfo.currentUser.unread
     ? styles.iconUnread
     : styles.iconRead;
 
   const iconName = isThick ? 'lock' : 'server';
 
   const threadDetails = React.useMemo(
     () => (
       <View style={styles.threadDetails}>
         <View style={styles.header}>
           <View style={styles.iconContainer}>
             <Icon name={iconName} size={12} style={iconStyle} />
           </View>
           <ThreadAncestorsLabel threadInfo={data.threadInfo} />
         </View>
         <View style={styles.row}>
           <SingleLine style={threadNameStyle}>
             {resolvedThreadInfo.uiName}
           </SingleLine>
         </View>
         <View style={styles.row}>
-          <MessagePreview
-            messageInfo={data.mostRecentMessageInfo}
-            threadInfo={data.threadInfo}
-          />
+          <MessagePreview threadInfo={data.threadInfo} />
           <Text style={lastActivityStyle}>{lastActivity}</Text>
         </View>
       </View>
     ),
     [
       iconStyle,
       data.threadInfo,
       iconName,
       lastActivity,
       lastActivityStyle,
       resolvedThreadInfo.uiName,
       styles.header,
       styles.iconContainer,
       styles.row,
       styles.threadDetails,
       threadNameStyle,
-      data.mostRecentMessageInfo,
     ],
   );
 
   const swipeableThreadContent = React.useMemo(
     () => (
       <Button
         onPress={onPress}
         iosFormat="highlight"
         iosHighlightUnderlayColor={colors.listIosHighlightUnderlay}
         iosActiveOpacity={0.85}
         style={styles.container}
       >
         <View style={styles.content}>
           {unreadDot}
           {threadAvatar}
           {threadDetails}
         </View>
       </Button>
     ),
     [
       colors.listIosHighlightUnderlay,
       onPress,
       styles.container,
       styles.content,
       threadAvatar,
       threadDetails,
       unreadDot,
     ],
   );
 
   const swipeableThread = React.useMemo(
     () => (
       <SwipeableThread
         threadInfo={data.threadInfo}
         mostRecentNonLocalMessage={data.mostRecentNonLocalMessage}
         onSwipeableWillOpen={onSwipeableWillOpen}
         currentlyOpenedSwipeableId={currentlyOpenedSwipeableId}
         iconSize={24}
       >
         {swipeableThreadContent}
       </SwipeableThread>
     ),
     [
       currentlyOpenedSwipeableId,
       data.mostRecentNonLocalMessage,
       data.threadInfo,
       onSwipeableWillOpen,
       swipeableThreadContent,
     ],
   );
 
   const chatThreadListItem = React.useMemo(
     () => (
       <>
         {swipeableThread}
         {sidebars}
       </>
     ),
     [sidebars, swipeableThread],
   );
 
   return chatThreadListItem;
 }
 
 const chatThreadListItemHeight = 70;
 const spacerHeight = 6;
 const unboundStyles = {
   container: {
     height: chatThreadListItemHeight,
     justifyContent: 'center',
     backgroundColor: 'listBackground',
   },
   content: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     alignItems: 'center',
   },
   avatarContainer: {
     marginLeft: 6,
     marginBottom: 12,
   },
   threadDetails: {
     paddingLeft: 12,
     paddingRight: 18,
     justifyContent: 'center',
     flex: 1,
     marginTop: 5,
   },
   lastActivity: {
     color: 'listForegroundTertiaryLabel',
     fontSize: 14,
     marginLeft: 10,
   },
   unreadLastActivity: {
     color: 'listForegroundLabel',
     fontWeight: 'bold',
   },
   row: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     alignItems: 'center',
   },
   threadName: {
     color: 'listForegroundSecondaryLabel',
     flex: 1,
     fontSize: 21,
   },
   unreadThreadName: {
     color: 'listForegroundLabel',
     fontWeight: '500',
   },
   spacer: {
     height: spacerHeight,
   },
   header: {
     flexDirection: 'row',
     alignItems: 'center',
   },
   iconContainer: {
     marginRight: 6,
   },
   iconRead: {
     color: 'listForegroundTertiaryLabel',
   },
   iconUnread: {
     color: 'listForegroundLabel',
   },
 };
 
 export { ChatThreadListItem, chatThreadListItemHeight, spacerHeight };
diff --git a/native/chat/message-preview.react.js b/native/chat/message-preview.react.js
index 3469c3fa2..1d5771d7b 100644
--- a/native/chat/message-preview.react.js
+++ b/native/chat/message-preview.react.js
@@ -1,102 +1,102 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text } from 'react-native';
 
 import { useThreadChatMentionCandidates } from 'lib/hooks/chat-mention-hooks.js';
+import { useMessageInfoForPreview } from 'lib/hooks/message-hooks.js';
 import { useMessagePreview } from 'lib/shared/message-utils.js';
-import { type MessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 
 import SingleLine from '../components/single-line.react.js';
 import { getDefaultTextMessageRules } from '../markdown/rules.react.js';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
-  +messageInfo: ?MessageInfo,
   +threadInfo: ThreadInfo,
 };
 function MessagePreview(props: Props): React.Node {
-  const { messageInfo, threadInfo } = props;
+  const { threadInfo } = props;
 
   const chatMentionCandidates = useThreadChatMentionCandidates(threadInfo);
+  const messageInfoForPreview = useMessageInfoForPreview(threadInfo);
   const messagePreviewResult = useMessagePreview(
-    messageInfo,
+    messageInfoForPreview,
     threadInfo,
     getDefaultTextMessageRules(chatMentionCandidates).simpleMarkdownRules,
   );
   const styles = useStyles(unboundStyles);
   if (!messagePreviewResult) {
     return (
       <Text style={styles.noMessages} numberOfLines={1}>
         No messages
       </Text>
     );
   }
   const { message, username } = messagePreviewResult;
 
   let messageStyle;
   if (message.style === 'unread') {
     messageStyle = styles.unread;
   } else if (message.style === 'primary') {
     messageStyle = styles.primary;
   } else if (message.style === 'secondary') {
     messageStyle = styles.secondary;
   }
   invariant(
     messageStyle,
     `MessagePreview doesn't support ${message.style} style for message, ` +
       'only unread, primary, and secondary',
   );
 
   if (!username) {
     return (
       <SingleLine style={[styles.lastMessage, messageStyle]}>
         {message.text}
       </SingleLine>
     );
   }
 
   let usernameStyle;
   if (username.style === 'unread') {
     usernameStyle = styles.unread;
   } else if (username.style === 'secondary') {
     usernameStyle = styles.secondary;
   }
   invariant(
     usernameStyle,
     `MessagePreview doesn't support ${username.style} style for username, ` +
       'only unread and secondary',
   );
   return (
     <Text style={[styles.lastMessage, messageStyle]} numberOfLines={1}>
       <Text style={usernameStyle}>{`${username.text}: `}</Text>
       {message.text}
     </Text>
   );
 }
 
 const unboundStyles = {
   lastMessage: {
     flex: 1,
     fontSize: 14,
   },
   primary: {
     color: 'listForegroundTertiaryLabel',
   },
   secondary: {
     color: 'listForegroundTertiaryLabel',
   },
   unread: {
     color: 'listForegroundLabel',
   },
   noMessages: {
     color: 'listForegroundTertiaryLabel',
     flex: 1,
     fontSize: 14,
     fontStyle: 'italic',
   },
 };
 
 export default MessagePreview;
diff --git a/native/chat/subchannel-item.react.js b/native/chat/subchannel-item.react.js
index c2c5e8cbd..e2a9beaf7 100644
--- a/native/chat/subchannel-item.react.js
+++ b/native/chat/subchannel-item.react.js
@@ -1,90 +1,86 @@
 // @flow
 
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import type { ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import { shortAbsoluteDate } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import MessagePreview from './message-preview.react.js';
 import SingleLine from '../components/single-line.react.js';
 import SWMansionIcon from '../components/swmansion-icon.react.js';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
   +subchannelInfo: ChatThreadItem,
 };
 function SubchannelItem(props: Props): React.Node {
-  const { lastUpdatedTime, threadInfo, mostRecentMessageInfo } =
-    props.subchannelInfo;
+  const { lastUpdatedTime, threadInfo } = props.subchannelInfo;
   const { uiName } = useResolvedThreadInfo(threadInfo);
 
   const lastActivity = shortAbsoluteDate(lastUpdatedTime);
 
   const styles = useStyles(unboundStyles);
   const unreadStyle = threadInfo.currentUser.unread ? styles.unread : null;
 
   return (
     <View style={styles.outerView}>
       <View style={styles.itemRowContainer}>
         <View style={styles.iconWrapper}>
           <SWMansionIcon
             name="message-square"
             style={[styles.icon, unreadStyle]}
           />
         </View>
         <SingleLine style={[styles.name, unreadStyle]}>{uiName}</SingleLine>
       </View>
       <View style={styles.itemRowContainer}>
-        <MessagePreview
-          messageInfo={mostRecentMessageInfo}
-          threadInfo={threadInfo}
-        />
+        <MessagePreview threadInfo={threadInfo} />
         <Text style={[styles.lastActivity, unreadStyle]}>{lastActivity}</Text>
       </View>
     </View>
   );
 }
 const fontSize = 14;
 const unboundStyles = {
   outerView: {
     flex: 1,
     flexDirection: 'column',
     justifyContent: 'center',
     paddingVertical: 8,
     paddingHorizontal: 8,
     height: 60,
   },
   itemRowContainer: {
     flexDirection: 'row',
     alignItems: 'center',
   },
   unread: {
     color: 'listForegroundLabel',
     fontWeight: 'bold',
   },
   name: {
     color: 'listForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
     paddingBottom: 8,
   },
   lastActivity: {
     color: 'listForegroundTertiaryLabel',
     fontSize,
     marginLeft: 10,
   },
   iconWrapper: {
     marginRight: 8,
     alignItems: 'center',
   },
   icon: {
     fontSize: 22,
     color: 'listForegroundSecondaryLabel',
     alignItems: 'center',
     height: 24,
   },
 };
 
 export default SubchannelItem;
diff --git a/web/chat/chat-thread-list-item.react.js b/web/chat/chat-thread-list-item.react.js
index 7a7309060..2a4fb7554 100644
--- a/web/chat/chat-thread-list-item.react.js
+++ b/web/chat/chat-thread-list-item.react.js
@@ -1,178 +1,174 @@
 // @flow
 
 import {
   faServer as server,
   faLock as lock,
 } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import classNames from 'classnames';
 import * as React from 'react';
 
 import SWMansionIcon from 'lib/components/swmansion-icon.react.js';
 import type { ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import { useAncestorThreads } from 'lib/shared/ancestor-threads.js';
 import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
 import { shortAbsoluteDate } from 'lib/utils/date-utils.js';
 import {
   useResolvedThreadInfo,
   useResolvedThreadInfos,
 } from 'lib/utils/entity-helpers.js';
 
 import ChatThreadListItemMenu from './chat-thread-list-item-menu.react.js';
 import ChatThreadListSeeMoreSidebars from './chat-thread-list-see-more-sidebars.react.js';
 import ChatThreadListSidebar from './chat-thread-list-sidebar.react.js';
 import css from './chat-thread-list.css';
 import MessagePreview from './message-preview.react.js';
 import ThreadAvatar from '../avatars/thread-avatar.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import {
   useOnClickThread,
   useThreadIsActive,
 } from '../selectors/thread-selectors.js';
 
 type Props = {
   +item: ChatThreadItem,
 };
 function ChatThreadListItem(props: Props): React.Node {
   const { item } = props;
   const {
     threadInfo,
     lastUpdatedTimeIncludingSidebars,
     mostRecentNonLocalMessage,
-    mostRecentMessageInfo,
   } = item;
   const { id: threadID, currentUser } = threadInfo;
 
   const unresolvedAncestorThreads = useAncestorThreads(threadInfo);
   const ancestorThreads = useResolvedThreadInfos(unresolvedAncestorThreads);
 
   const lastActivity = shortAbsoluteDate(lastUpdatedTimeIncludingSidebars);
 
   const active = useThreadIsActive(threadID);
   const isCreateMode = useSelector(
     state => state.navInfo.chatMode === 'create',
   );
 
   const onClick = useOnClickThread(item.threadInfo);
 
   const selectItemIfNotActiveCreation = React.useCallback(
     (event: SyntheticEvent<HTMLAnchorElement>) => {
       if (!isCreateMode || !active) {
         onClick(event);
       }
     },
     [isCreateMode, active, onClick],
   );
 
   const containerClassName = classNames({
     [css.thread]: true,
     [css.activeThread]: active,
   });
 
   const { unread } = currentUser;
   const titleClassName = classNames({
     [css.title]: true,
     [css.unread]: unread,
   });
   const lastActivityClassName = classNames({
     [css.lastActivity]: true,
     [css.unread]: unread,
     [css.dark]: !unread,
   });
 
   const breadCrumbsClassName = classNames(css.breadCrumbs, {
     [css.unread]: unread,
   });
 
   let unreadDot;
   if (unread) {
     unreadDot = <div className={css.unreadDot} />;
   }
 
   const sidebars = item.sidebars.map((sidebarItem, index) => {
     if (sidebarItem.type === 'sidebar') {
       const { type, ...sidebarInfo } = sidebarItem;
       return (
         <ChatThreadListSidebar
           sidebarInfo={sidebarInfo}
           isSubsequentItem={index > 0}
           key={sidebarInfo.threadInfo.id}
         />
       );
     } else if (sidebarItem.type === 'seeMore') {
       return (
         <ChatThreadListSeeMoreSidebars
           threadInfo={item.threadInfo}
           unread={sidebarItem.unread}
           key="seeMore"
         />
       );
     } else {
       return <div className={css.spacer} key="spacer" />;
     }
   });
 
   const ancestorPath = ancestorThreads.map((thread, idx) => {
     const isNotLast = idx !== ancestorThreads.length - 1;
     const chevron = isNotLast && (
       <span className={css.breadCrumb}>
         <SWMansionIcon icon="chevron-right" size={10} />
       </span>
     );
 
     return (
       <React.Fragment key={thread.id}>
         <span className={css.breadCrumb}>{thread.uiName}</span>
         {chevron}
       </React.Fragment>
     );
   });
 
   const { uiName } = useResolvedThreadInfo(threadInfo);
 
   const isThick = threadTypeIsThick(threadInfo.type);
 
   const iconClass = unread ? css.iconUnread : css.iconRead;
   const icon = isThick ? lock : server;
   const breadCrumbs = isThick ? 'Local DM' : ancestorPath;
 
   return (
     <>
       <a className={containerClassName} onClick={selectItemIfNotActiveCreation}>
         <div className={css.colorContainer}>
           <div className={css.avatarContainer}>
             <div className={css.dotContainer}>{unreadDot}</div>
             <ThreadAvatar size="M" threadInfo={threadInfo} />
           </div>
         </div>
         <div className={css.threadButton}>
           <div className={css.header}>
             <div className={css.iconWrapper}>
               <FontAwesomeIcon size="xs" className={iconClass} icon={icon} />
             </div>
             <p className={breadCrumbsClassName}>{breadCrumbs}</p>
           </div>
           <div className={css.threadRow}>
             <div className={titleClassName}>{uiName}</div>
           </div>
           <div className={css.threadRow}>
-            <MessagePreview
-              messageInfo={mostRecentMessageInfo}
-              threadInfo={threadInfo}
-            />
+            <MessagePreview threadInfo={threadInfo} />
           </div>
         </div>
         <div>
           <ChatThreadListItemMenu
             threadInfo={threadInfo}
             mostRecentNonLocalMessage={mostRecentNonLocalMessage}
           />
           <div className={lastActivityClassName}>{lastActivity}</div>
         </div>
       </a>
       {sidebars}
     </>
   );
 }
 
 export default ChatThreadListItem;
diff --git a/web/chat/message-preview.react.js b/web/chat/message-preview.react.js
index ae3d1fc61..9c5aeca27 100644
--- a/web/chat/message-preview.react.js
+++ b/web/chat/message-preview.react.js
@@ -1,81 +1,77 @@
 // @flow
 
 import classNames from 'classnames';
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { useThreadChatMentionCandidates } from 'lib/hooks/chat-mention-hooks.js';
+import { useMessageInfoForPreview } from 'lib/hooks/message-hooks.js';
 import { useMessagePreview } from 'lib/shared/message-utils.js';
-import { type MessageInfo } from 'lib/types/message-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 
 import css from './chat-thread-list.css';
 import { getDefaultTextMessageRules } from '../markdown/rules.react.js';
 
 type Props = {
-  +messageInfo: ?MessageInfo,
   +threadInfo: ThreadInfo,
 };
 function MessagePreview(props: Props): React.Node {
-  const { messageInfo, threadInfo } = props;
+  const { threadInfo } = props;
   const chatMentionCandidates = useThreadChatMentionCandidates(threadInfo);
+  const messageInfoForPreview = useMessageInfoForPreview(threadInfo);
   const messagePreviewResult = useMessagePreview(
-    messageInfo,
+    messageInfoForPreview,
     threadInfo,
     getDefaultTextMessageRules(chatMentionCandidates).simpleMarkdownRules,
   );
 
-  if (!messageInfo) {
+  if (!messagePreviewResult) {
     return (
       <div className={classNames(css.lastMessage, css.dark, css.italic)}>
         No messages
       </div>
     );
   }
-  invariant(
-    messagePreviewResult,
-    'useMessagePreview should only return falsey if pass null or undefined',
-  );
   const { message, username } = messagePreviewResult;
 
   let usernameText = null;
   if (username) {
     let usernameStyle;
     if (username.style === 'unread') {
       usernameStyle = css.unread;
     } else if (username.style === 'secondary') {
       usernameStyle = css.messagePreviewSecondary;
     }
     invariant(
       usernameStyle,
       `MessagePreview doesn't support ${username.style} style for username, ` +
         'only unread and secondary',
     );
     usernameText = (
       <span className={usernameStyle}>{`${username.text}: `}</span>
     );
   }
 
   let messageStyle;
   if (message.style === 'unread') {
     messageStyle = css.unread;
   } else if (message.style === 'primary') {
     messageStyle = css.messagePreviewPrimary;
   } else if (message.style === 'secondary') {
     messageStyle = css.messagePreviewSecondary;
   }
   invariant(
     messageStyle,
     `MessagePreview doesn't support ${message.style} style for message, ` +
       'only unread, primary, and secondary',
   );
 
   return (
     <div className={classNames(css.lastMessage, messageStyle)}>
       {usernameText}
       {message.text}
     </div>
   );
 }
 
 export default MessagePreview;
diff --git a/web/modals/threads/sidebars/sidebar.react.js b/web/modals/threads/sidebars/sidebar.react.js
index 8a97c9083..619df2688 100644
--- a/web/modals/threads/sidebars/sidebar.react.js
+++ b/web/modals/threads/sidebars/sidebar.react.js
@@ -1,103 +1,105 @@
 // @flow
 
 import classNames from 'classnames';
 import * as React from 'react';
 
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { useThreadChatMentionCandidates } from 'lib/hooks/chat-mention-hooks.js';
+import { useMessageInfoForPreview } from 'lib/hooks/message-hooks.js';
 import type { ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import { useMessagePreview } from 'lib/shared/message-utils.js';
 import { shortAbsoluteDate } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import css from './sidebars-modal.css';
 import ThreadAvatar from '../../../avatars/thread-avatar.react.js';
 import Button from '../../../components/button.react.js';
 import { getDefaultTextMessageRules } from '../../../markdown/rules.react.js';
 import { useOnClickThread } from '../../../selectors/thread-selectors.js';
 
 type Props = {
   +sidebar: ChatThreadItem,
   +isLastItem?: boolean,
 };
 
 function Sidebar(props: Props): React.Node {
   const { sidebar, isLastItem } = props;
-  const { threadInfo, lastUpdatedTime, mostRecentMessageInfo } = sidebar;
+  const { threadInfo, lastUpdatedTime } = sidebar;
   const { unread } = threadInfo.currentUser;
 
   const { popModal } = useModalContext();
 
   const navigateToThread = useOnClickThread(threadInfo);
 
   const onClickThread = React.useCallback(
     (event: SyntheticEvent<HTMLButtonElement>) => {
       popModal();
       navigateToThread(event);
     },
     [popModal, navigateToThread],
   );
 
   const sidebarInfoClassName = classNames({
     [css.sidebarInfo]: true,
     [css.unread]: unread,
   });
 
   const previewTextClassName = classNames([
     css.longTextEllipsis,
     css.avatarOffset,
   ]);
 
   const lastActivity = React.useMemo(
     () => shortAbsoluteDate(lastUpdatedTime),
     [lastUpdatedTime],
   );
 
   const chatMentionCandidates = useThreadChatMentionCandidates(threadInfo);
+  const messageInfoForPreview = useMessageInfoForPreview(threadInfo);
   const messagePreviewResult = useMessagePreview(
-    mostRecentMessageInfo,
+    messageInfoForPreview,
     threadInfo,
     getDefaultTextMessageRules(chatMentionCandidates).simpleMarkdownRules,
   );
 
   const lastMessage = React.useMemo(() => {
     if (!messagePreviewResult) {
       return <div className={css.noMessage}>No messages</div>;
     }
     const { message, username } = messagePreviewResult;
     const previewText = username
       ? `${username.text}: ${message.text}`
       : message.text;
     return (
       <>
         <div className={previewTextClassName}>{previewText}</div>
         <div className={css.lastActivity}>{lastActivity}</div>
       </>
     );
   }, [lastActivity, messagePreviewResult, previewTextClassName]);
 
   const { uiName } = useResolvedThreadInfo(threadInfo);
 
   return (
     <Button className={css.sidebarContainer} onClick={onClickThread}>
       <img
         className={css.sidebarArrow}
         src={
           isLastItem
             ? 'images/arrow_sidebar_last.svg'
             : 'images/arrow_sidebar.svg'
         }
         alt="sidebar arrow"
       />
       <div className={sidebarInfoClassName}>
         <div className={css.avatarContainer}>
           <ThreadAvatar size="XS" threadInfo={threadInfo} />
           <div className={css.longTextEllipsis}>{uiName}</div>
         </div>
         <div className={css.lastMessage}>{lastMessage}</div>
       </div>
     </Button>
   );
 }
 
 export default Sidebar;
diff --git a/web/modals/threads/subchannels/subchannel.react.js b/web/modals/threads/subchannels/subchannel.react.js
index b6994d2ae..507b18408 100644
--- a/web/modals/threads/subchannels/subchannel.react.js
+++ b/web/modals/threads/subchannels/subchannel.react.js
@@ -1,90 +1,88 @@
 // @flow
 
 import classNames from 'classnames';
 import * as React from 'react';
 
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { useThreadChatMentionCandidates } from 'lib/hooks/chat-mention-hooks.js';
+import { useMessageInfoForPreview } from 'lib/hooks/message-hooks.js';
 import { type ChatThreadItem } from 'lib/selectors/chat-selectors.js';
 import { useMessagePreview } from 'lib/shared/message-utils.js';
 import { shortAbsoluteDate } from 'lib/utils/date-utils.js';
 import { useResolvedThreadInfo } from 'lib/utils/entity-helpers.js';
 
 import css from './subchannels-modal.css';
 import ThreadAvatar from '../../../avatars/thread-avatar.react.js';
 import Button from '../../../components/button.react.js';
 import { getDefaultTextMessageRules } from '../../../markdown/rules.react.js';
 import { useOnClickThread } from '../../../selectors/thread-selectors.js';
 
 type Props = {
   +chatThreadItem: ChatThreadItem,
 };
 
 function Subchannel(props: Props): React.Node {
   const { chatThreadItem } = props;
-  const {
-    threadInfo,
-    mostRecentMessageInfo,
-    lastUpdatedTimeIncludingSidebars,
-  } = chatThreadItem;
+  const { threadInfo, lastUpdatedTimeIncludingSidebars } = chatThreadItem;
 
   const { unread } = threadInfo.currentUser;
 
   const subchannelTitleClassName = classNames({
     [css.subchannelInfo]: true,
     [css.unread]: unread,
   });
 
   const { popModal } = useModalContext();
 
   const navigateToThread = useOnClickThread(threadInfo);
 
   const onClickThread = React.useCallback(
     (event: SyntheticEvent<HTMLButtonElement>) => {
       popModal();
       navigateToThread(event);
     },
     [popModal, navigateToThread],
   );
 
   const lastActivity = React.useMemo(
     () => shortAbsoluteDate(lastUpdatedTimeIncludingSidebars),
     [lastUpdatedTimeIncludingSidebars],
   );
   const chatMentionCandidates = useThreadChatMentionCandidates(threadInfo);
+  const messageInfoForPreview = useMessageInfoForPreview(threadInfo);
   const messagePreviewResult = useMessagePreview(
-    mostRecentMessageInfo,
+    messageInfoForPreview,
     threadInfo,
     getDefaultTextMessageRules(chatMentionCandidates).simpleMarkdownRules,
   );
 
   const lastMessage = React.useMemo(() => {
     if (!messagePreviewResult) {
       return <div className={css.noMessage}>No messages</div>;
     }
     const { message, username } = messagePreviewResult;
     const previewText = username
       ? `${username.text}: ${message.text}`
       : message.text;
     return (
       <>
         <div className={css.longTextEllipsis}>{previewText}</div>
         <div className={css.lastActivity}>{lastActivity}</div>
       </>
     );
   }, [lastActivity, messagePreviewResult]);
 
   const { uiName } = useResolvedThreadInfo(threadInfo);
 
   return (
     <Button className={css.subchannelContainer} onClick={onClickThread}>
       <ThreadAvatar size="S" threadInfo={threadInfo} />
       <div className={subchannelTitleClassName}>
         <div className={css.longTextEllipsis}>{uiName}</div>
         <div className={css.lastMessage}>{lastMessage}</div>
       </div>
     </Button>
   );
 }
 
 export default Subchannel;